Merge branch 'master' into blender2.8

In addition to pack of conflicts listed below, also had to comment out particle part of new Alembic code... :/

Conflicts:
	intern/ghost/intern/GHOST_WindowWin32.cpp
	source/blender/blenkernel/BKE_effect.h
	source/blender/blenkernel/BKE_pointcache.h
	source/blender/blenkernel/intern/cloth.c
	source/blender/blenkernel/intern/depsgraph.c
	source/blender/blenkernel/intern/dynamicpaint.c
	source/blender/blenkernel/intern/effect.c
	source/blender/blenkernel/intern/particle_system.c
	source/blender/blenkernel/intern/pointcache.c
	source/blender/blenkernel/intern/rigidbody.c
	source/blender/blenkernel/intern/smoke.c
	source/blender/blenkernel/intern/softbody.c
	source/blender/depsgraph/intern/builder/deg_builder_relations.cc
	source/blender/gpu/intern/gpu_debug.c
	source/blender/makesdna/DNA_object_types.h
	source/blender/makesrna/intern/rna_particle.c

build_files/build_environment/install_deps.sh

@@ -337,7 +337,7 @@ OSL_FORCE_REBUILD=false
 OSL_SKIP=false
 
 # OpenSubdiv needs to be compiled for now
-OSD_VERSION="3.0.2"
+OSD_VERSION="3.0.5"
 OSD_VERSION_MIN=$OSD_VERSION
 OSD_FORCE_BUILD=false
 OSD_FORCE_REBUILD=false
@@ -739,7 +739,7 @@ OSL_SOURCE_REPO=( "https://github.com/Nazg-Gul/OpenShadingLanguage.git" )
 OSL_SOURCE_REPO_UID="7d40ff5fe8e47b030042afb92d0e955f5aa96f48"
 OSL_SOURCE_REPO_BRANCH="blender-fixes"
 
-OSD_USE_REPO=true
+OSD_USE_REPO=false
 # Script foo to make the version string compliant with the archive name:
 # ${Varname//SearchForThisChar/ReplaceWithThisChar}
 OSD_SOURCE=( "https://github.com/PixarAnimationStudios/OpenSubdiv/archive/v${OSD_VERSION//./_}.tar.gz" )
@@ -1907,7 +1907,7 @@ compile_OSD() {
   fi
 
   # To be changed each time we make edits that would modify the compiled result!
-  osd_magic=1
+  osd_magic=2
   _init_osd
 
   # Clean install if needed!

build_files/cmake/platform/platform_apple.cmake

@@ -0,0 +1,430 @@
+# ***** 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) 2016, Blender Foundation
+# All rights reserved.
+#
+# Contributor(s): Sergey Sharybin.
+#
+# ***** END GPL LICENSE BLOCK *****
+
+# Libraries configuration for Apple.
+
+if(NOT DEFINED LIBDIR)
+	set(LIBDIR ${CMAKE_SOURCE_DIR}/../lib/darwin-9.x.universal)
+else()
+	message(STATUS "Using pre-compiled LIBDIR: ${LIBDIR}")
+endif()
+if(NOT EXISTS "${LIBDIR}/")
+	message(FATAL_ERROR "Mac OSX requires pre-compiled libs at: '${LIBDIR}'")
+endif()
+
+if(WITH_OPENAL)
+	find_package(OpenAL)
+	if(OPENAL_FOUND)
+		set(WITH_OPENAL ON)
+		set(OPENAL_INCLUDE_DIR "${LIBDIR}/openal/include")
+	else()
+		set(WITH_OPENAL OFF)
+	endif()
+endif()
+
+if(WITH_ALEMBIC)
+	set(ALEMBIC ${LIBDIR}/alembic)
+	set(ALEMBIC_INCLUDE_DIR ${ALEMBIC}/include)
+	set(ALEMBIC_INCLUDE_DIRS ${ALEMBIC_INCLUDE_DIR})
+	set(ALEMBIC_LIBPATH ${ALEMBIC}/lib)
+	set(ALEMBIC_LIBRARIES Alembic)
+endif()
+
+if(WITH_OPENSUBDIV)
+	set(OPENSUBDIV ${LIBDIR}/opensubdiv)
+	set(OPENSUBDIV_LIBPATH ${OPENSUBDIV}/lib)
+	find_library(OSL_LIB_UTIL NAMES osdutil PATHS ${OPENSUBDIV_LIBPATH})
+	find_library(OSL_LIB_CPU NAMES osdCPU PATHS ${OPENSUBDIV_LIBPATH})
+	find_library(OSL_LIB_GPU NAMES osdGPU PATHS ${OPENSUBDIV_LIBPATH})
+	set(OPENSUBDIV_INCLUDE_DIR ${OPENSUBDIV}/include)
+	set(OPENSUBDIV_INCLUDE_DIRS ${OPENSUBDIV_INCLUDE_DIR})
+	list(APPEND OPENSUBDIV_LIBRARIES ${OSL_LIB_UTIL} ${OSL_LIB_CPU} ${OSL_LIB_GPU})
+endif()
+
+if(WITH_JACK)
+	find_library(JACK_FRAMEWORK
+		NAMES jackmp
+	)
+	set(JACK_INCLUDE_DIRS ${JACK_FRAMEWORK}/headers)
+	if(NOT JACK_FRAMEWORK)
+		set(WITH_JACK OFF)
+	endif()
+endif()
+
+if(WITH_CODEC_SNDFILE)
+	set(SNDFILE ${LIBDIR}/sndfile)
+	set(SNDFILE_INCLUDE_DIRS ${SNDFILE}/include)
+	set(SNDFILE_LIBRARIES sndfile FLAC ogg vorbis vorbisenc)
+	set(SNDFILE_LIBPATH ${SNDFILE}/lib ${FFMPEG}/lib)  # TODO, deprecate
+endif()
+
+if(WITH_PYTHON)
+	# we use precompiled libraries for py 3.5 and up by default
+	set(PYTHON_VERSION 3.5)
+	if(NOT WITH_PYTHON_MODULE AND NOT WITH_PYTHON_FRAMEWORK)
+		# normally cached but not since we include them with blender
+		set(PYTHON_INCLUDE_DIR "${LIBDIR}/python/include/python${PYTHON_VERSION}m")
+		set(PYTHON_EXECUTABLE "${LIBDIR}/python/bin/python${PYTHON_VERSION}m")
+		set(PYTHON_LIBRARY python${PYTHON_VERSION}m)
+		set(PYTHON_LIBPATH "${LIBDIR}/python/lib/python${PYTHON_VERSION}")
+		# set(PYTHON_LINKFLAGS "-u _PyMac_Error")  # won't  build with this enabled
+	else()
+		# module must be compiled against Python framework
+		set(_py_framework "/Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}")
+
+		set(PYTHON_INCLUDE_DIR "${_py_framework}/include/python${PYTHON_VERSION}m")
+		set(PYTHON_EXECUTABLE "${_py_framework}/bin/python${PYTHON_VERSION}m")
+		set(PYTHON_LIBPATH "${_py_framework}/lib/python${PYTHON_VERSION}/config-${PYTHON_VERSION}m")
+		#set(PYTHON_LIBRARY python${PYTHON_VERSION})
+		#set(PYTHON_LINKFLAGS "-u _PyMac_Error -framework Python")  # won't  build with this enabled
+
+		unset(_py_framework)
+	endif()
+
+	# uncached vars
+	set(PYTHON_INCLUDE_DIRS "${PYTHON_INCLUDE_DIR}")
+	set(PYTHON_LIBRARIES  "${PYTHON_LIBRARY}")
+
+	if(NOT EXISTS "${PYTHON_EXECUTABLE}")
+		message(FATAL_ERROR "Python executable missing: ${PYTHON_EXECUTABLE}")
+	endif()
+endif()
+
+if(WITH_FFTW3)
+	set(FFTW3 ${LIBDIR}/fftw3)
+	set(FFTW3_INCLUDE_DIRS ${FFTW3}/include)
+	set(FFTW3_LIBRARIES fftw3)
+	set(FFTW3_LIBPATH ${FFTW3}/lib)
+endif()
+
+set(PNG_LIBRARIES png)
+set(JPEG_LIBRARIES jpeg)
+
+set(ZLIB /usr)
+set(ZLIB_INCLUDE_DIRS "${ZLIB}/include")
+set(ZLIB_LIBRARIES z bz2)
+
+set(FREETYPE ${LIBDIR}/freetype)
+set(FREETYPE_INCLUDE_DIRS ${FREETYPE}/include ${FREETYPE}/include/freetype2)
+set(FREETYPE_LIBPATH ${FREETYPE}/lib)
+set(FREETYPE_LIBRARY freetype)
+
+if(WITH_IMAGE_OPENEXR)
+	set(OPENEXR ${LIBDIR}/openexr)
+	set(OPENEXR_INCLUDE_DIR ${OPENEXR}/include)
+	set(OPENEXR_INCLUDE_DIRS ${OPENEXR_INCLUDE_DIR} ${OPENEXR}/include/OpenEXR)
+	set(OPENEXR_LIBRARIES Iex Half IlmImf Imath IlmThread)
+	set(OPENEXR_LIBPATH ${OPENEXR}/lib)
+endif()
+
+if(WITH_CODEC_FFMPEG)
+	set(FFMPEG ${LIBDIR}/ffmpeg)
+	set(FFMPEG_INCLUDE_DIRS ${FFMPEG}/include)
+	set(FFMPEG_LIBRARIES
+		avcodec avdevice avformat avutil
+		mp3lame swscale x264 xvidcore theora theoradec theoraenc vorbis vorbisenc vorbisfile ogg
+	)
+	set(FFMPEG_LIBPATH ${FFMPEG}/lib)
+endif()
+
+find_library(SYSTEMSTUBS_LIBRARY
+	NAMES
+	SystemStubs
+	PATHS
+)
+mark_as_advanced(SYSTEMSTUBS_LIBRARY)
+if(SYSTEMSTUBS_LIBRARY)
+	list(APPEND PLATFORM_LINKLIBS SystemStubs)
+endif()
+
+set(PLATFORM_CFLAGS "-pipe -funsigned-char")
+set(PLATFORM_LINKFLAGS
+	"-fexceptions -framework CoreServices -framework Foundation -framework IOKit -framework AppKit -framework Cocoa -framework Carbon -framework AudioUnit -framework AudioToolbox -framework CoreAudio"
+)
+if(WITH_CODEC_QUICKTIME)
+	set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -framework QTKit")
+	if(CMAKE_OSX_ARCHITECTURES MATCHES i386)
+		set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -framework QuickTime")
+		# libSDL still needs 32bit carbon quicktime
+	endif()
+endif()
+
+if(WITH_CXX11)
+	list(APPEND PLATFORM_LINKLIBS c++)
+else()
+	list(APPEND PLATFORM_LINKLIBS stdc++)
+endif()
+
+if(WITH_JACK)
+	set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -F/Library/Frameworks -weak_framework jackmp")
+endif()
+
+if(WITH_PYTHON_MODULE OR WITH_PYTHON_FRAMEWORK)
+	# force cmake to link right framework
+	set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} /Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/Python")
+endif()
+
+if(WITH_OPENCOLLADA)
+	set(OPENCOLLADA ${LIBDIR}/opencollada)
+
+	set(OPENCOLLADA_INCLUDE_DIRS
+		${LIBDIR}/opencollada/include/COLLADAStreamWriter
+		${LIBDIR}/opencollada/include/COLLADABaseUtils
+		${LIBDIR}/opencollada/include/COLLADAFramework
+		${LIBDIR}/opencollada/include/COLLADASaxFrameworkLoader
+		${LIBDIR}/opencollada/include/GeneratedSaxParser
+	)
+
+	set(OPENCOLLADA_LIBPATH ${OPENCOLLADA}/lib)
+	set(OPENCOLLADA_LIBRARIES
+		OpenCOLLADASaxFrameworkLoader
+		-lOpenCOLLADAFramework
+		-lOpenCOLLADABaseUtils
+		-lOpenCOLLADAStreamWriter
+		-lMathMLSolver
+		-lGeneratedSaxParser
+		-lxml2 -lbuffer -lftoa
+	)
+	# Use UTF functions from collada if LLVM is not enabled
+	if(NOT WITH_LLVM)
+		list(APPEND OPENCOLLADA_LIBRARIES -lUTF)
+	endif()
+	# pcre is bundled with openCollada
+	#set(PCRE ${LIBDIR}/pcre)
+	#set(PCRE_LIBPATH ${PCRE}/lib)
+	set(PCRE_LIBRARIES pcre)
+	#libxml2 is used
+	#set(EXPAT ${LIBDIR}/expat)
+	#set(EXPAT_LIBPATH ${EXPAT}/lib)
+	set(EXPAT_LIB)
+endif()
+
+if(WITH_SDL)
+	set(SDL ${LIBDIR}/sdl)
+	set(SDL_INCLUDE_DIR ${SDL}/include)
+	set(SDL_LIBRARY SDL2)
+	set(SDL_LIBPATH ${SDL}/lib)
+	set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -lazy_framework ForceFeedback")
+endif()
+
+set(PNG "${LIBDIR}/png")
+set(PNG_INCLUDE_DIRS "${PNG}/include")
+set(PNG_LIBPATH ${PNG}/lib)
+
+set(JPEG "${LIBDIR}/jpeg")
+set(JPEG_INCLUDE_DIR "${JPEG}/include")
+set(JPEG_LIBPATH ${JPEG}/lib)
+
+if(WITH_IMAGE_TIFF)
+	set(TIFF ${LIBDIR}/tiff)
+	set(TIFF_INCLUDE_DIR ${TIFF}/include)
+	set(TIFF_LIBRARY tiff)
+	set(TIFF_LIBPATH ${TIFF}/lib)
+endif()
+
+if(WITH_BOOST)
+	set(BOOST ${LIBDIR}/boost)
+	set(BOOST_INCLUDE_DIR ${BOOST}/include)
+	set(BOOST_LIBRARIES
+		boost_date_time-mt
+		boost_filesystem-mt
+		boost_regex-mt
+		boost_system-mt
+		boost_thread-mt
+		boost_wave-mt
+	)
+	if(WITH_INTERNATIONAL)
+		list(APPEND BOOST_LIBRARIES boost_locale-mt)
+	endif()
+	if(WITH_CYCLES_NETWORK)
+		list(APPEND BOOST_LIBRARIES boost_serialization-mt)
+	endif()
+	if(WITH_OPENVDB)
+		list(APPEND BOOST_LIBRARIES boost_iostreams-mt)
+	endif()
+	set(BOOST_LIBPATH ${BOOST}/lib)
+	set(BOOST_DEFINITIONS)
+endif()
+
+if(WITH_INTERNATIONAL OR WITH_CODEC_FFMPEG)
+	set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -liconv") # boost_locale and ffmpeg needs it !
+endif()
+
+if(WITH_OPENIMAGEIO)
+	set(OPENIMAGEIO ${LIBDIR}/openimageio)
+	set(OPENIMAGEIO_INCLUDE_DIRS ${OPENIMAGEIO}/include)
+	set(OPENIMAGEIO_LIBRARIES
+		${OPENIMAGEIO}/lib/libOpenImageIO.a
+		${PNG_LIBRARIES}
+		${JPEG_LIBRARIES}
+		${TIFF_LIBRARY}
+		${OPENEXR_LIBRARIES}
+		${ZLIB_LIBRARIES}
+	)
+	set(OPENIMAGEIO_LIBPATH
+		${OPENIMAGEIO}/lib
+		${JPEG_LIBPATH}
+		${PNG_LIBPATH}
+		${TIFF_LIBPATH}
+		${OPENEXR_LIBPATH}
+		${ZLIB_LIBPATH}
+	)
+	set(OPENIMAGEIO_DEFINITIONS "-DOIIO_STATIC_BUILD")
+	set(OPENIMAGEIO_IDIFF "${LIBDIR}/openimageio/bin/idiff")
+endif()
+
+if(WITH_OPENCOLORIO)
+	set(OPENCOLORIO ${LIBDIR}/opencolorio)
+	set(OPENCOLORIO_INCLUDE_DIRS ${OPENCOLORIO}/include)
+	set(OPENCOLORIO_LIBRARIES OpenColorIO tinyxml yaml-cpp)
+	set(OPENCOLORIO_LIBPATH ${OPENCOLORIO}/lib)
+endif()
+
+if(WITH_OPENVDB)
+	set(OPENVDB ${LIBDIR}/openvdb)
+	set(OPENVDB_INCLUDE_DIRS ${OPENVDB}/include)
+	set(TBB_INCLUDE_DIRS ${LIBDIR}/tbb/include)
+	set(TBB_LIBRARIES ${LIBDIR}/tbb/lib/libtbb.a)
+	set(OPENVDB_LIBRARIES openvdb blosc ${TBB_LIBRARIES})
+	set(OPENVDB_LIBPATH ${LIBDIR}/openvdb/lib)
+	set(OPENVDB_DEFINITIONS)
+endif()
+
+if(WITH_LLVM)
+	set(LLVM_ROOT_DIR ${LIBDIR}/llvm CACHE PATH	"Path to the LLVM installation")
+	set(LLVM_VERSION "3.4" CACHE STRING	"Version of LLVM to use")
+	if(EXISTS "${LLVM_ROOT_DIR}/bin/llvm-config")
+		set(LLVM_CONFIG "${LLVM_ROOT_DIR}/bin/llvm-config")
+	else()
+		set(LLVM_CONFIG llvm-config)
+	endif()
+	execute_process(COMMAND ${LLVM_CONFIG} --version
+			OUTPUT_VARIABLE LLVM_VERSION
+			OUTPUT_STRIP_TRAILING_WHITESPACE)
+	execute_process(COMMAND ${LLVM_CONFIG} --prefix
+			OUTPUT_VARIABLE LLVM_ROOT_DIR
+			OUTPUT_STRIP_TRAILING_WHITESPACE)
+	execute_process(COMMAND ${LLVM_CONFIG} --libdir
+			OUTPUT_VARIABLE LLVM_LIBPATH
+			OUTPUT_STRIP_TRAILING_WHITESPACE)
+	find_library(LLVM_LIBRARY
+		      NAMES LLVMAnalysis # first of a whole bunch of libs to get
+		      PATHS ${LLVM_LIBPATH})
+
+	if(LLVM_LIBRARY AND LLVM_ROOT_DIR 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})
+		else()
+			set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -lLLVM-3.4")
+		endif()
+	else()
+		message(FATAL_ERROR "LLVM not found.")
+	endif()
+endif()
+
+if(WITH_CYCLES_OSL)
+	set(CYCLES_OSL ${LIBDIR}/osl CACHE PATH "Path to OpenShadingLanguage installation")
+
+	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)
+	# WARNING! depends on correct order of OSL libs linking
+	list(APPEND OSL_LIBRARIES ${OSL_LIB_COMP} -force_load ${OSL_LIB_EXEC} ${OSL_LIB_QUERY})
+	find_path(OSL_INCLUDE_DIR OSL/oslclosure.h PATHS ${CYCLES_OSL}/include)
+	find_program(OSL_COMPILER NAMES oslc PATHS ${CYCLES_OSL}/bin)
+
+	if(OSL_INCLUDE_DIR AND OSL_LIBRARIES AND OSL_COMPILER)
+		set(OSL_FOUND TRUE)
+	else()
+		message(STATUS "OSL not found")
+		set(WITH_CYCLES_OSL OFF)
+	endif()
+endif()
+
+if(WITH_OPENMP)
+	execute_process(COMMAND ${CMAKE_C_COMPILER} --version OUTPUT_VARIABLE COMPILER_VENDOR)
+	string(SUBSTRING "${COMPILER_VENDOR}" 0 5 VENDOR_NAME) # truncate output
+	if(${VENDOR_NAME} MATCHES "Apple") # Apple does not support OpenMP reliable with gcc and not with clang
+		set(WITH_OPENMP OFF)
+	else() # vanilla gcc or clang_omp support OpenMP
+		message(STATUS "Using special OpenMP enabled compiler !") # letting find_package(OpenMP) module work for gcc
+		if(CMAKE_C_COMPILER_ID MATCHES "Clang") # clang-omp in darwin libs
+			set(OPENMP_FOUND ON)
+			set(OpenMP_C_FLAGS "-fopenmp" CACHE STRING "C compiler flags for OpenMP parallization" FORCE)
+			set(OpenMP_CXX_FLAGS "-fopenmp" CACHE STRING "C++ compiler flags for OpenMP parallization" FORCE)
+			include_directories(${LIBDIR}/openmp/include)
+			link_directories(${LIBDIR}/openmp/lib)
+			# This is a workaround for our helperbinaries ( datatoc, masgfmt, ... ),
+			# They are linked also to omp lib, so we need it in builddir for runtime exexcution,
+			# TODO: remove all unneeded dependencies from these
+
+			# for intermediate binaries, in respect to lib ID
+			execute_process(
+				COMMAND ditto -arch ${CMAKE_OSX_ARCHITECTURES}
+				${LIBDIR}/openmp/lib/libiomp5.dylib
+				${CMAKE_BINARY_DIR}/Resources/lib/libiomp5.dylib)
+		endif()
+	endif()
+endif()
+
+set(EXETYPE MACOSX_BUNDLE)
+
+set(CMAKE_C_FLAGS_DEBUG "-fno-strict-aliasing -g")
+set(CMAKE_CXX_FLAGS_DEBUG "-fno-strict-aliasing -g")
+if(CMAKE_OSX_ARCHITECTURES MATCHES "x86_64" OR CMAKE_OSX_ARCHITECTURES MATCHES "i386")
+	set(CMAKE_CXX_FLAGS_RELEASE "-O2 -mdynamic-no-pic -msse -msse2 -msse3 -mssse3")
+	set(CMAKE_C_FLAGS_RELEASE "-O2 -mdynamic-no-pic  -msse -msse2 -msse3 -mssse3")
+	if(NOT CMAKE_C_COMPILER_ID MATCHES "Clang")
+		set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -ftree-vectorize  -fvariable-expansion-in-unroller")
+		set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ftree-vectorize  -fvariable-expansion-in-unroller")
+	endif()
+else()
+	set(CMAKE_C_FLAGS_RELEASE "-mdynamic-no-pic -fno-strict-aliasing")
+	set(CMAKE_CXX_FLAGS_RELEASE "-mdynamic-no-pic -fno-strict-aliasing")
+endif()
+
+if(${XCODE_VERSION} VERSION_EQUAL 5 OR ${XCODE_VERSION} VERSION_GREATER 5)
+	# Xcode 5 is always using CLANG, which has too low template depth of 128 for libmv
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftemplate-depth=1024")
+endif()
+# Get rid of eventually clashes, we export some symbols explicite as local
+set(PLATFORM_LINKFLAGS
+	"${PLATFORM_LINKFLAGS} -Xlinker -unexported_symbols_list -Xlinker ${CMAKE_SOURCE_DIR}/source/creator/osx_locals.map"
+)
+
+if(WITH_CXX11)
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
+	set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -stdlib=libc++")
+endif()
+
+# Suppress ranlib "has no symbols" warnings (workaround for T48250)
+set(CMAKE_C_ARCHIVE_CREATE   "<CMAKE_AR> Scr <TARGET> <LINK_FLAGS> <OBJECTS>")
+set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> Scr <TARGET> <LINK_FLAGS> <OBJECTS>")
+set(CMAKE_C_ARCHIVE_FINISH   "<CMAKE_RANLIB> -no_warning_for_no_symbols -c <TARGET>")
+set(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_RANLIB> -no_warning_for_no_symbols -c <TARGET>")

build_files/cmake/platform/platform_unix.cmake

@@ -0,0 +1,425 @@
+# ***** 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) 2016, Blender Foundation
+# All rights reserved.
+#
+# Contributor(s): Sergey Sharybin.
+#
+# ***** END GPL LICENSE BLOCK *****
+
+# Libraries configuration for any *nix system including Linux and Unix.
+
+macro(find_package_wrapper)
+	if(WITH_STATIC_LIBS)
+		find_package_static(${ARGV})
+	else()
+		find_package(${ARGV})
+	endif()
+endmacro()
+
+find_package_wrapper(JPEG REQUIRED)
+find_package_wrapper(PNG REQUIRED)
+find_package_wrapper(ZLIB REQUIRED)
+find_package_wrapper(Freetype REQUIRED)
+
+if(WITH_LZO AND WITH_SYSTEM_LZO)
+	find_package_wrapper(LZO)
+	if(NOT LZO_FOUND)
+		message(FATAL_ERROR "Failed finding system LZO version!")
+	endif()
+endif()
+
+if(WITH_SYSTEM_EIGEN3)
+	find_package_wrapper(Eigen3)
+	if(NOT EIGEN3_FOUND)
+		message(FATAL_ERROR "Failed finding system Eigen3 version!")
+	endif()
+endif()
+# else values are set below for all platforms
+
+if(WITH_PYTHON)
+	# No way to set py35, remove for now.
+	# find_package(PythonLibs)
+
+	# Use our own instead, since without 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_SYSTEM_AUDASPACE)
+	find_package_wrapper(Audaspace)
+	if(NOT AUDASPACE_FOUND OR NOT AUDASPACE_C_FOUND)
+		message(FATAL_ERROR "Audaspace external library not found!")
+	endif()
+endif()
+
+if(WITH_OPENAL)
+	find_package_wrapper(OpenAL)
+	if(NOT OPENAL_FOUND)
+		set(WITH_OPENAL OFF)
+	endif()
+endif()
+
+if(WITH_SDL)
+	if(WITH_SDL_DYNLOAD)
+		set(SDL_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/extern/sdlew/include/SDL2")
+		set(SDL_LIBRARY)
+	else()
+		find_package_wrapper(SDL2)
+		if(SDL2_FOUND)
+			# Use same names for both versions of SDL until we move to 2.x.
+			set(SDL_INCLUDE_DIR "${SDL2_INCLUDE_DIR}")
+			set(SDL_LIBRARY "${SDL2_LIBRARY}")
+			set(SDL_FOUND "${SDL2_FOUND}")
+		else()
+			find_package_wrapper(SDL)
+		endif()
+		mark_as_advanced(
+			SDL_INCLUDE_DIR
+			SDL_LIBRARY
+		)
+		# unset(SDLMAIN_LIBRARY CACHE)
+		if(NOT SDL_FOUND)
+			set(WITH_SDL OFF)
+		endif()
+	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)
+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(SPACENAV_FOUND)
+		# use generic names within blenders buildsystem.
+		set(NDOF_INCLUDE_DIRS ${SPACENAV_INCLUDE_DIRS})
+		set(NDOF_LIBRARIES ${SPACENAV_LIBRARIES})
+	else()
+		set(WITH_INPUT_NDOF OFF)
+	endif()
+endif()
+
+if(WITH_CYCLES_OSL)
+	set(CYCLES_OSL ${LIBDIR}/osl CACHE PATH "Path to OpenShadingLanguage installation")
+	if(NOT OSL_ROOT)
+		set(OSL_ROOT ${CYCLES_OSL})
+	endif()
+	find_package_wrapper(OpenShadingLanguage)
+	if(OSL_FOUND)
+		if(${OSL_LIBRARY_VERSION_MAJOR} EQUAL "1" AND ${OSL_LIBRARY_VERSION_MINOR} LESS "6")
+			# Note: --whole-archive is needed to force loading of all symbols in liboslexec,
+			# otherwise LLVM is missing the osl_allocate_closure_component function
+			set(OSL_LIBRARIES
+				${OSL_OSLCOMP_LIBRARY}
+				-Wl,--whole-archive ${OSL_OSLEXEC_LIBRARY}
+				-Wl,--no-whole-archive ${OSL_OSLQUERY_LIBRARY}
+			)
+		endif()
+	else()
+		message(STATUS "OSL not found, disabling it from Cycles")
+		set(WITH_CYCLES_OSL OFF)
+	endif()
+endif()
+
+if(WITH_OPENVDB)
+	find_package_wrapper(OpenVDB)
+	find_package_wrapper(TBB)
+	if(NOT OPENVDB_FOUND OR NOT TBB_FOUND)
+		set(WITH_OPENVDB OFF)
+		set(WITH_OPENVDB_BLOSC OFF)
+		message(STATUS "OpenVDB not found, disabling it")
+	endif()
+endif()
+
+if(WITH_ALEMBIC)
+	find_package_wrapper(Alembic)
+
+	if(WITH_ALEMBIC_HDF5)
+		set(HDF5_ROOT_DIR ${LIBDIR}/hdf5)
+		find_package_wrapper(HDF5)
+	endif()
+
+	if(NOT ALEMBIC_FOUND OR (WITH_ALEMBIC_HDF5 AND NOT HDF5_FOUND))
+		set(WITH_ALEMBIC OFF)
+		set(WITH_ALEMBIC_HDF5 OFF)
+	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_CYCLES_OSL)
+			if(NOT (${OSL_LIBRARY_VERSION_MAJOR} EQUAL "1" AND ${OSL_LIBRARY_VERSION_MINOR} LESS "6"))
+				list(APPEND __boost_packages wave)
+			else()
+			endif()
+		endif()
+		if(WITH_INTERNATIONAL)
+			list(APPEND __boost_packages locale)
+		endif()
+		if(WITH_CYCLES_NETWORK)
+			list(APPEND __boost_packages serialization)
+		endif()
+		if(WITH_OPENVDB)
+			list(APPEND __boost_packages iostreams)
+		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)
+	if(NOT OPENIMAGEIO_PUGIXML_FOUND AND WITH_CYCLES_STANDALONE)
+		find_package_wrapper(PugiXML)
+	else()
+		set(PUGIXML_INCLUDE_DIR "${OPENIMAGEIO_INCLUDE_DIR/OpenImageIO}")
+		set(PUGIXML_LIBRARIES "")
+	endif()
+
+	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()
+
+if(WITH_LLVM)
+	find_package_wrapper(LLVM)
+
+	if(NOT LLVM_FOUND)
+		set(WITH_LLVM OFF)
+		message(STATUS "LLVM not found")
+	endif()
+endif()
+
+if(WITH_LLVM OR WITH_SDL_DYNLOAD)
+	# Fix for conflict with Mesa llvmpipe
+	set(PLATFORM_LINKFLAGS
+		"${PLATFORM_LINKFLAGS} -Wl,--version-script='${CMAKE_SOURCE_DIR}/source/creator/blender.map'"
+	)
+endif()
+
+if(WITH_OPENSUBDIV)
+	find_package_wrapper(OpenSubdiv)
+
+	set(OPENSUBDIV_LIBRARIES ${OPENSUBDIV_LIBRARIES})
+	set(OPENSUBDIV_LIBPATH)  # TODO, remove and reference the absolute path everywhere
+
+	if(NOT OPENSUBDIV_FOUND)
+		set(WITH_OPENSUBDIV OFF)
+		message(STATUS "OpenSubdiv not found")
+	endif()
+endif()
+
+# OpenSuse needs lutil, ArchLinux not, for now keep, can avoid by using --as-needed
+list(APPEND PLATFORM_LINKLIBS -lutil -lc -lm)
+
+find_package(Threads REQUIRED)
+list(APPEND PLATFORM_LINKLIBS ${CMAKE_THREAD_LIBS_INIT})
+# used by other platforms
+set(PTHREADS_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
+
+if(CMAKE_DL_LIBS)
+	list(APPEND PLATFORM_LINKLIBS ${CMAKE_DL_LIBS})
+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()
+
+# 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")
+
+	# use ld.gold linker if available, could make optional
+	execute_process(
+		COMMAND ${CMAKE_C_COMPILER} -fuse-ld=gold -Wl,--version
+		ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
+	if("${LD_VERSION}" MATCHES "GNU gold")
+		set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fuse-ld=gold")
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fuse-ld=gold")
+	else()
+		message(STATUS "GNU gold linker isn't available, using the default system linker.")
+	endif()
+	unset(LD_VERSION)
+
+# 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()

build_files/cmake/platform/platform_win32.cmake

@@ -0,0 +1,87 @@
+# ***** 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) 2016, Blender Foundation
+# All rights reserved.
+#
+# Contributor(s): Sergey Sharybin.
+#
+# ***** END GPL LICENSE BLOCK *****
+
+# Libraries configuration for Windows.
+
+add_definitions(-DWIN32)
+
+if(MSVC)
+	include(platform_win32_msvc)
+elseif(CMAKE_COMPILER_IS_GNUCC)
+	include(platform_win32_mingw)
+endif()
+
+# Things common to both mingw and MSVC  should go here
+
+set(WINTAB_INC ${LIBDIR}/wintab/include)
+
+if(WITH_OPENAL)
+	set(OPENAL ${LIBDIR}/openal)
+	set(OPENALDIR ${LIBDIR}/openal)
+	set(OPENAL_INCLUDE_DIR ${OPENAL}/include)
+	if(MSVC)
+		set(OPENAL_LIBRARY openal32)
+	else()
+		set(OPENAL_LIBRARY wrap_oal)
+	endif()
+	set(OPENAL_LIBPATH ${OPENAL}/lib)
+endif()
+
+if(WITH_CODEC_SNDFILE)
+	set(SNDFILE ${LIBDIR}/sndfile)
+	set(SNDFILE_INCLUDE_DIRS ${SNDFILE}/include)
+	set(SNDFILE_LIBRARIES libsndfile-1)
+	set(SNDFILE_LIBPATH ${SNDFILE}/lib) # TODO, deprecate
+endif()
+
+if(WITH_RAYOPTIMIZATION AND SUPPORT_SSE_BUILD)
+	add_definitions(-D__SSE__ -D__MMX__)
+endif()
+
+if(WITH_CYCLES_OSL)
+	set(CYCLES_OSL ${LIBDIR}/osl CACHE PATH "Path to OpenShadingLanguage installation")
+
+	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)
+	find_library(OSL_LIB_EXEC_DEBUG NAMES oslexec_d PATHS ${CYCLES_OSL}/lib)
+	find_library(OSL_LIB_COMP_DEBUG NAMES oslcomp_d PATHS ${CYCLES_OSL}/lib)
+	find_library(OSL_LIB_QUERY_DEBUG NAMES oslquery_d PATHS ${CYCLES_OSL}/lib)
+	list(APPEND OSL_LIBRARIES
+		optimized ${OSL_LIB_COMP}
+		optimized ${OSL_LIB_EXEC}
+		optimized ${OSL_LIB_QUERY}
+		debug ${OSL_LIB_EXEC_DEBUG}
+		debug ${OSL_LIB_COMP_DEBUG}
+		debug ${OSL_LIB_QUERY_DEBUG}
+	)
+	find_path(OSL_INCLUDE_DIR OSL/oslclosure.h PATHS ${CYCLES_OSL}/include)
+	find_program(OSL_COMPILER NAMES oslc PATHS ${CYCLES_OSL}/bin)
+
+	if(OSL_INCLUDE_DIR AND OSL_LIBRARIES AND OSL_COMPILER)
+		set(OSL_FOUND TRUE)
+	else()
+		message(STATUS "OSL not found")
+		set(WITH_CYCLES_OSL OFF)
+	endif()
+endif()

build_files/cmake/platform/platform_win32_mingw.cmake

@@ -0,0 +1,302 @@
+# ***** 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) 2016, Blender Foundation
+# All rights reserved.
+#
+# Contributor(s): Sergey Sharybin.
+#
+# ***** END GPL LICENSE BLOCK *****
+
+# Libraries configuration for Windows when compiling with MinGW.
+
+# keep GCC specific stuff here
+include(CheckCSourceCompiles)
+# Setup 64bit and 64bit windows systems
+CHECK_C_SOURCE_COMPILES("
+	#ifndef __MINGW64__
+	#error
+	#endif
+	int main(void) { return 0; }
+	"
+	WITH_MINGW64
+)
+
+if(NOT DEFINED LIBDIR)
+	if(WITH_MINGW64)
+		message(STATUS "Compiling for 64 bit with MinGW-w64.")
+		set(LIBDIR ${CMAKE_SOURCE_DIR}/../lib/mingw64)
+	else()
+		message(STATUS "Compiling for 32 bit with MinGW-w32.")
+		set(LIBDIR ${CMAKE_SOURCE_DIR}/../lib/mingw32)
+
+		if(WITH_RAYOPTIMIZATION)
+			message(WARNING "MinGW-w32 is known to be unstable with 'WITH_RAYOPTIMIZATION' option enabled.")
+		endif()
+	endif()
+else()
+	message(STATUS "Using pre-compiled LIBDIR: ${LIBDIR}")
+endif()
+if(NOT EXISTS "${LIBDIR}/")
+	message(FATAL_ERROR "Windows requires pre-compiled libs at: '${LIBDIR}'")
+endif()
+
+list(APPEND PLATFORM_LINKLIBS
+	-lshell32 -lshfolder -lgdi32 -lmsvcrt -lwinmm -lmingw32 -lm -lws2_32
+	-lz -lstdc++ -lole32 -luuid -lwsock32 -lpsapi -ldbghelp
+)
+
+if(WITH_INPUT_IME)
+	list(APPEND PLATFORM_LINKLIBS -limm32)
+endif()
+
+set(PLATFORM_CFLAGS "-pipe -funsigned-char -fno-strict-aliasing")
+
+if(WITH_MINGW64)
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fpermissive")
+	list(APPEND PLATFORM_LINKLIBS -lpthread)
+
+	add_definitions(-DFREE_WINDOWS64 -DMS_WIN64)
+endif()
+
+add_definitions(-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE)
+
+add_definitions(-DFREE_WINDOWS)
+
+set(PNG "${LIBDIR}/png")
+set(PNG_INCLUDE_DIRS "${PNG}/include")
+set(PNG_LIBPATH ${PNG}/lib) # not cmake defined
+
+if(WITH_MINGW64)
+	set(JPEG_LIBRARIES jpeg)
+else()
+	set(JPEG_LIBRARIES libjpeg)
+endif()
+set(PNG_LIBRARIES png)
+
+set(ZLIB ${LIBDIR}/zlib)
+set(ZLIB_INCLUDE_DIRS ${ZLIB}/include)
+set(ZLIB_LIBPATH ${ZLIB}/lib)
+set(ZLIB_LIBRARIES z)
+
+set(JPEG "${LIBDIR}/jpeg")
+set(JPEG_INCLUDE_DIR "${JPEG}/include")
+set(JPEG_LIBPATH ${JPEG}/lib) # not cmake defined
+
+# comes with own pthread library
+if(NOT WITH_MINGW64)
+	set(PTHREADS ${LIBDIR}/pthreads)
+	#set(PTHREADS_INCLUDE_DIRS ${PTHREADS}/include)
+	set(PTHREADS_LIBPATH ${PTHREADS}/lib)
+	set(PTHREADS_LIBRARIES pthreadGC2)
+endif()
+
+set(FREETYPE ${LIBDIR}/freetype)
+set(FREETYPE_INCLUDE_DIRS ${FREETYPE}/include ${FREETYPE}/include/freetype2)
+set(FREETYPE_LIBPATH ${FREETYPE}/lib)
+set(FREETYPE_LIBRARY freetype)
+
+if(WITH_FFTW3)
+	set(FFTW3 ${LIBDIR}/fftw3)
+	set(FFTW3_LIBRARIES fftw3)
+	set(FFTW3_INCLUDE_DIRS ${FFTW3}/include)
+	set(FFTW3_LIBPATH ${FFTW3}/lib)
+endif()
+
+if(WITH_OPENCOLLADA)
+	set(OPENCOLLADA ${LIBDIR}/opencollada)
+	set(OPENCOLLADA_INCLUDE_DIRS
+		${OPENCOLLADA}/include/opencollada/COLLADAStreamWriter
+		${OPENCOLLADA}/include/opencollada/COLLADABaseUtils
+		${OPENCOLLADA}/include/opencollada/COLLADAFramework
+		${OPENCOLLADA}/include/opencollada/COLLADASaxFrameworkLoader
+		${OPENCOLLADA}/include/opencollada/GeneratedSaxParser
+	)
+	set(OPENCOLLADA_LIBPATH ${OPENCOLLADA}/lib/opencollada)
+	set(OPENCOLLADA_LIBRARIES
+		OpenCOLLADAStreamWriter
+		OpenCOLLADASaxFrameworkLoader
+		OpenCOLLADAFramework
+		OpenCOLLADABaseUtils
+		GeneratedSaxParser
+		UTF MathMLSolver buffer ftoa xml
+	)
+	set(PCRE_LIBRARIES pcre)
+endif()
+
+if(WITH_CODEC_FFMPEG)
+	set(FFMPEG ${LIBDIR}/ffmpeg)
+	set(FFMPEG_INCLUDE_DIRS ${FFMPEG}/include)
+	if(WITH_MINGW64)
+		set(FFMPEG_LIBRARIES avcodec.dll avformat.dll avdevice.dll avutil.dll swscale.dll swresample.dll)
+	else()
+		set(FFMPEG_LIBRARIES avcodec-55 avformat-55 avdevice-55 avutil-52 swscale-2)
+	endif()
+	set(FFMPEG_LIBPATH ${FFMPEG}/lib)
+endif()
+
+if(WITH_IMAGE_OPENEXR)
+	set(OPENEXR ${LIBDIR}/openexr)
+	set(OPENEXR_INCLUDE_DIR ${OPENEXR}/include)
+	set(OPENEXR_INCLUDE_DIRS ${OPENEXR}/include/OpenEXR)
+	set(OPENEXR_LIBRARIES Half IlmImf Imath IlmThread Iex)
+	set(OPENEXR_LIBPATH ${OPENEXR}/lib)
+endif()
+
+if(WITH_IMAGE_TIFF)
+	set(TIFF ${LIBDIR}/tiff)
+	set(TIFF_LIBRARY tiff)
+	set(TIFF_INCLUDE_DIR ${TIFF}/include)
+	set(TIFF_LIBPATH ${TIFF}/lib)
+endif()
+
+if(WITH_JACK)
+	set(JACK ${LIBDIR}/jack)
+	set(JACK_INCLUDE_DIRS ${JACK}/include/jack ${JACK}/include)
+	set(JACK_LIBRARIES jack)
+	set(JACK_LIBPATH ${JACK}/lib)
+
+	# TODO, gives linking errors, force off
+	set(WITH_JACK OFF)
+endif()
+
+if(WITH_PYTHON)
+	# normally cached but not since we include them with blender
+	set(PYTHON_VERSION 3.5) #  CACHE STRING)
+	string(REPLACE "." "" _PYTHON_VERSION_NO_DOTS ${PYTHON_VERSION})
+	set(PYTHON_INCLUDE_DIR "${LIBDIR}/python/include/python${PYTHON_VERSION}")  # CACHE PATH)
+	set(PYTHON_LIBRARY "${LIBDIR}/python/lib/python${_PYTHON_VERSION_NO_DOTS}mw.lib")  # CACHE FILEPATH)
+	unset(_PYTHON_VERSION_NO_DOTS)
+
+	# uncached vars
+	set(PYTHON_INCLUDE_DIRS "${PYTHON_INCLUDE_DIR}")
+	set(PYTHON_LIBRARIES  "${PYTHON_LIBRARY}")
+endif()
+
+if(WITH_BOOST)
+	set(BOOST ${LIBDIR}/boost)
+	set(BOOST_INCLUDE_DIR ${BOOST}/include)
+	if(WITH_MINGW64)
+		set(BOOST_POSTFIX "mgw47-mt-s-1_49")
+		set(BOOST_DEBUG_POSTFIX "mgw47-mt-sd-1_49")
+	else()
+		set(BOOST_POSTFIX "mgw46-mt-s-1_49")
+		set(BOOST_DEBUG_POSTFIX "mgw46-mt-sd-1_49")
+	endif()
+	set(BOOST_LIBRARIES
+		optimized boost_date_time-${BOOST_POSTFIX} boost_filesystem-${BOOST_POSTFIX}
+		boost_regex-${BOOST_POSTFIX}
+		boost_system-${BOOST_POSTFIX} boost_thread-${BOOST_POSTFIX}
+		debug boost_date_time-${BOOST_DEBUG_POSTFIX} boost_filesystem-${BOOST_DEBUG_POSTFIX}
+		boost_regex-${BOOST_DEBUG_POSTFIX}
+		boost_system-${BOOST_DEBUG_POSTFIX} boost_thread-${BOOST_DEBUG_POSTFIX})
+	if(WITH_INTERNATIONAL)
+		set(BOOST_LIBRARIES ${BOOST_LIBRARIES}
+			optimized boost_locale-${BOOST_POSTFIX}
+			debug boost_locale-${BOOST_DEBUG_POSTFIX}
+		)
+	endif()
+	if(WITH_CYCLES_OSL)
+		set(BOOST_LIBRARIES ${BOOST_LIBRARIES}
+			optimized boost_wave-${BOOST_POSTFIX}
+			debug boost_wave-${BOOST_DEBUG_POSTFIX}
+		)
+	endif()
+	set(BOOST_LIBPATH ${BOOST}/lib)
+	set(BOOST_DEFINITIONS "-DBOOST_ALL_NO_LIB -DBOOST_THREAD_USE_LIB ")
+endif()
+
+if(WITH_OPENIMAGEIO)
+	set(OPENIMAGEIO ${LIBDIR}/openimageio)
+	set(OPENIMAGEIO_INCLUDE_DIRS ${OPENIMAGEIO}/include)
+	set(OPENIMAGEIO_LIBRARIES OpenImageIO)
+	set(OPENIMAGEIO_LIBPATH ${OPENIMAGEIO}/lib)
+	set(OPENIMAGEIO_DEFINITIONS "")
+	set(OPENIMAGEIO_IDIFF "${OPENIMAGEIO}/bin/idiff.exe")
+endif()
+
+if(WITH_LLVM)
+	set(LLVM_ROOT_DIR ${LIBDIR}/llvm CACHE PATH	"Path to the LLVM installation")
+	set(LLVM_LIBPATH ${LLVM_ROOT_DIR}/lib)
+	# Explicitly set llvm lib order.
+	#---- WARNING ON GCC ORDER OF LIBS IS IMPORTANT, DO NOT CHANGE! ---------
+	set(LLVM_LIBRARY LLVMSelectionDAG LLVMCodeGen LLVMScalarOpts LLVMAnalysis LLVMArchive
+		LLVMAsmParser LLVMAsmPrinter
+		LLVMBitReader LLVMBitWriter
+		LLVMDebugInfo LLVMExecutionEngine
+		LLVMInstCombine LLVMInstrumentation
+		LLVMInterpreter LLVMJIT
+		LLVMLinker LLVMMC
+		LLVMMCDisassembler LLVMMCJIT
+		LLVMMCParser LLVMObject
+		LLVMRuntimeDyld
+		LLVMSupport
+		LLVMTableGen LLVMTarget
+		LLVMTransformUtils LLVMVectorize
+		LLVMX86AsmParser LLVMX86AsmPrinter
+		LLVMX86CodeGen LLVMX86Desc
+		LLVMX86Disassembler LLVMX86Info
+		LLVMX86Utils LLVMipa
+		LLVMipo LLVMCore)
+	# imagehelp is needed by LLVM 3.1 on MinGW, check lib\Support\Windows\Signals.inc
+	list(APPEND PLATFORM_LINKLIBS -limagehlp)
+endif()
+
+if(WITH_OPENCOLORIO)
+	set(OPENCOLORIO ${LIBDIR}/opencolorio)
+	set(OPENCOLORIO_INCLUDE_DIRS ${OPENCOLORIO}/include)
+	set(OPENCOLORIO_LIBRARIES OpenColorIO)
+	set(OPENCOLORIO_LIBPATH ${OPENCOLORIO}/lib)
+	set(OPENCOLORIO_DEFINITIONS)
+endif()
+
+if(WITH_SDL)
+	set(SDL ${LIBDIR}/sdl)
+	set(SDL_INCLUDE_DIR ${SDL}/include)
+	set(SDL_LIBRARY SDL)
+	set(SDL_LIBPATH ${SDL}/lib)
+endif()
+
+if(WITH_OPENVDB)
+	set(OPENVDB ${LIBDIR}/openvdb)
+	set(OPENVDB_INCLUDE_DIRS ${OPENVDB}/include)
+	set(OPENVDB_LIBRARIES openvdb ${TBB_LIBRARIES})
+	set(OPENVDB_LIBPATH ${LIBDIR}/openvdb/lib)
+	set(OPENVDB_DEFINITIONS)
+endif()
+
+if(WITH_ALEMBIC)
+	# TODO(sergey): For until someone drops by and compiles libraries for
+	# MinGW we allow users to compile their own Alembic library and use
+	# that via find_package(),
+	#
+	# Once precompiled libraries are there we'll use hardcoded locations.
+	find_package_wrapper(Alembic)
+	if(WITH_ALEMBIC_HDF5)
+		set(HDF5_ROOT_DIR ${LIBDIR}/hdf5)
+		find_package_wrapper(HDF5)
+	endif()
+	if(NOT ALEMBIC_FOUND OR (WITH_ALEMBIC_HDF5 AND NOT HDF5_FOUND))
+		set(WITH_ALEMBIC OFF)
+		set(WITH_ALEMBIC_HDF5 OFF)
+	endif()
+endif()
+
+set(PLATFORM_LINKFLAGS "-Xlinker --stack=2097152")
+
+## DISABLE - causes linking errors
+## for re-distribution, so users dont need mingw installed
+# set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -static-libgcc -static-libstdc++")

build_files/cmake/platform/platform_win32_msvc.cmake

@@ -0,0 +1,452 @@
+# ***** 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) 2016, Blender Foundation
+# All rights reserved.
+#
+# Contributor(s): Sergey Sharybin.
+#
+# ***** END GPL LICENSE BLOCK *****
+
+# Libraries configuration for Windows when compiling with MSVC.
+
+add_definitions(-DWIN32)
+# Minimum MSVC Version
+if(MSVC_VERSION EQUAL 1800)
+	set(_min_ver "18.0.31101")
+	if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS ${_min_ver})
+		message(FATAL_ERROR
+			"Visual Studio 2013 (Update 4, ${_min_ver}) required, "
+			"found (${CMAKE_CXX_COMPILER_VERSION})")
+	endif()
+endif()
+if(MSVC_VERSION EQUAL 1900)
+	set(_min_ver "19.0.24210")
+	if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS ${_min_ver})
+		message(FATAL_ERROR
+			"Visual Studio 2015 (Update 3, ${_min_ver}) required, "
+			"found (${CMAKE_CXX_COMPILER_VERSION})")
+	endif()
+endif()
+unset(_min_ver)
+
+# needed for some MSVC installations
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH:NO")
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SAFESEH:NO")
+set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /SAFESEH:NO")
+
+list(APPEND PLATFORM_LINKLIBS
+	ws2_32 vfw32 winmm kernel32 user32 gdi32 comdlg32
+	advapi32 shfolder shell32 ole32 oleaut32 uuid psapi Dbghelp
+)
+
+if(WITH_INPUT_IME)
+	list(APPEND PLATFORM_LINKLIBS imm32)
+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
+add_definitions(-D_ALLOW_KEYWORD_MACROS)
+
+# We want to support Vista level ABI
+add_definitions(-D_WIN32_WINNT=0x600)
+
+# Make cmake find the msvc redistributables
+set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP TRUE)
+include(InstallRequiredSystemLibraries)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /nologo /J /Gd /MP /EHsc")
+set(CMAKE_C_FLAGS     "${CMAKE_C_FLAGS} /nologo /J /Gd /MP")
+
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /MTd")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /MT")
+set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} /MT")
+set(CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL} /MT")
+set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /MT")
+set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} /MT")
+
+set(PLATFORM_LINKFLAGS "/SUBSYSTEM:CONSOLE /STACK:2097152 /INCREMENTAL:NO ")
+set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} /NODEFAULTLIB:msvcrt.lib /NODEFAULTLIB:msvcmrt.lib /NODEFAULTLIB:msvcurt.lib /NODEFAULTLIB:msvcrtd.lib ")
+
+# Ignore meaningless for us linker warnings.
+set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} /ignore:4049 /ignore:4217 /ignore:4221")
+set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /ignore:4221")
+
+# MSVC only, Mingw doesnt need
+if(CMAKE_CL_64)
+	set(PLATFORM_LINKFLAGS "/MACHINE:X64 /OPT:NOREF ${PLATFORM_LINKFLAGS}")
+else()
+	set(PLATFORM_LINKFLAGS "/MACHINE:IX86 /LARGEADDRESSAWARE ${PLATFORM_LINKFLAGS}")
+endif()
+
+set(PLATFORM_LINKFLAGS_DEBUG "/IGNORE:4099 /NODEFAULTLIB:libcmt.lib /NODEFAULTLIB:libc.lib")
+
+if(NOT DEFINED LIBDIR)
+
+	# Setup 64bit and 64bit windows systems
+	if(CMAKE_CL_64)
+		message(STATUS "64 bit compiler detected.")
+		set(LIBDIR_BASE "win64")
+	else()
+		message(STATUS "32 bit compiler detected.")
+		set(LIBDIR_BASE "windows")
+	endif()
+
+	if(MSVC_VERSION EQUAL 1900)
+		message(STATUS "Visual Studio 2015 detected.")
+		set(LIBDIR ${CMAKE_SOURCE_DIR}/../lib/${LIBDIR_BASE}_vc14)
+	else()
+		message(STATUS "Visual Studio 2013 detected.")
+		set(LIBDIR ${CMAKE_SOURCE_DIR}/../lib/${LIBDIR_BASE}_vc12)
+	endif()
+else()
+	message(STATUS "Using pre-compiled LIBDIR: ${LIBDIR}")
+endif()
+if(NOT EXISTS "${LIBDIR}/")
+	message(FATAL_ERROR "Windows requires pre-compiled libs at: '${LIBDIR}'")
+endif()
+
+# Add each of our libraries to our cmake_prefix_path so find_package() could work
+file(GLOB children RELATIVE ${LIBDIR} ${LIBDIR}/*)
+foreach(child ${children})
+	if(IS_DIRECTORY ${LIBDIR}/${child})
+		list(APPEND CMAKE_PREFIX_PATH  ${LIBDIR}/${child})
+	endif()
+endforeach()
+
+set(ZLIB_INCLUDE_DIRS ${LIBDIR}/zlib/include)
+set(ZLIB_LIBRARIES ${LIBDIR}/zlib/lib/libz_st.lib)
+set(ZLIB_INCLUDE_DIR ${LIBDIR}/zlib/include)
+set(ZLIB_LIBRARY ${LIBDIR}/zlib/lib/libz_st.lib)
+set(ZLIB_DIR ${LIBDIR}/zlib)
+#find_package(zlib) # we want to find before finding things that depend on it like png
+
+
+find_package(png)
+if(NOT PNG_FOUND)
+	message(WARNING "Using HARDCODED libpng locations")
+	set(PNG_PNG_INCLUDE_DIR ${LIBDIR}/png/include)
+	set(PNG_LIBRARIES libpng)
+	set(PNG "${LIBDIR}/png")
+	set(PNG_INCLUDE_DIRS "${PNG}/include")
+	set(PNG_LIBPATH ${PNG}/lib) # not cmake defined
+endif()
+
+set(JPEG_NAMES ${JPEG_NAMES} libjpeg)
+find_package(jpeg REQUIRED)
+
+set(PTHREADS_INCLUDE_DIRS ${LIBDIR}/pthreads/include)
+set(PTHREADS_LIBRARIES ${LIBDIR}/pthreads/lib/pthreadVC2.lib)
+
+set(FREETYPE ${LIBDIR}/freetype)
+set(FREETYPE_INCLUDE_DIRS
+	${LIBDIR}/freetype/include
+	${LIBDIR}/freetype/include/freetype2
+)
+set(FREETYPE_LIBRARY ${LIBDIR}/freetype/lib/freetype2ST.lib)
+find_package(freetype REQUIRED)
+
+if(WITH_FFTW3)
+	set(FFTW3 ${LIBDIR}/fftw3)
+	set(FFTW3_LIBRARIES libfftw)
+	set(FFTW3_INCLUDE_DIRS ${FFTW3}/include)
+	set(FFTW3_LIBPATH ${FFTW3}/lib)
+endif()
+
+if(WITH_OPENCOLLADA)
+	set(OPENCOLLADA ${LIBDIR}/opencollada)
+
+	set(OPENCOLLADA_INCLUDE_DIRS
+		${OPENCOLLADA}/include/opencollada/COLLADAStreamWriter
+		${OPENCOLLADA}/include/opencollada/COLLADABaseUtils
+		${OPENCOLLADA}/include/opencollada/COLLADAFramework
+		${OPENCOLLADA}/include/opencollada/COLLADASaxFrameworkLoader
+		${OPENCOLLADA}/include/opencollada/GeneratedSaxParser
+	)
+
+	set(OPENCOLLADA_LIBRARIES
+		${OPENCOLLADA}/lib/opencollada/OpenCOLLADASaxFrameworkLoader.lib
+		${OPENCOLLADA}/lib/opencollada/OpenCOLLADAFramework.lib
+		${OPENCOLLADA}/lib/opencollada/OpenCOLLADABaseUtils.lib
+		${OPENCOLLADA}/lib/opencollada/OpenCOLLADAStreamWriter.lib
+		${OPENCOLLADA}/lib/opencollada/MathMLSolver.lib
+		${OPENCOLLADA}/lib/opencollada/GeneratedSaxParser.lib
+		${OPENCOLLADA}/lib/opencollada/xml.lib
+		${OPENCOLLADA}/lib/opencollada/buffer.lib
+		${OPENCOLLADA}/lib/opencollada/ftoa.lib
+	)
+
+	if(NOT WITH_LLVM)
+		list(APPEND OPENCOLLADA_LIBRARIES ${OPENCOLLADA}/lib/opencollada/UTF.lib)
+	endif()
+
+	set(PCRE_LIBRARIES
+		${OPENCOLLADA}/lib/opencollada/pcre.lib
+	)
+endif()
+
+if(WITH_CODEC_FFMPEG)
+	set(FFMPEG_INCLUDE_DIRS
+		${LIBDIR}/ffmpeg/include
+		${LIBDIR}/ffmpeg/include/msvc
+	)
+	find_package(FFMPEG)
+	if(NOT FFMPEG_FOUND)
+		message(WARNING "Using HARDCODED ffmpeg locations")
+		set(FFMPEG_LIBRARY_VERSION 55)
+		set(FFMPEG_LIBRARY_VERSION_AVU 52)
+		set(FFMPEG_LIBRARIES
+			${LIBDIR}/ffmpeg/lib/avcodec-${FFMPEG_LIBRARY_VERSION}.lib
+			${LIBDIR}/ffmpeg/lib/avformat-${FFMPEG_LIBRARY_VERSION}.lib
+			${LIBDIR}/ffmpeg/lib/avdevice-${FFMPEG_LIBRARY_VERSION}.lib
+			${LIBDIR}/ffmpeg/lib/avutil-${FFMPEG_LIBRARY_VERSION_AVU}.lib
+			${LIBDIR}/ffmpeg/lib/swscale-2.lib
+			)
+	endif()
+endif()
+
+if(WITH_IMAGE_OPENEXR)
+	set(OPENEXR_ROOT_DIR ${LIBDIR}/openexr)
+	set(OPENEXR_VERSION "2.1")
+	find_package(OPENEXR REQUIRED)
+	if(NOT OPENEXR_FOUND)
+		message(WARNING "Using HARDCODED OpenEXR locations")
+		set(OPENEXR ${LIBDIR}/openexr)
+		set(OPENEXR_INCLUDE_DIR ${OPENEXR}/include)
+		set(OPENEXR_INCLUDE_DIRS ${OPENEXR_INCLUDE_DIR} ${OPENEXR}/include/OpenEXR)
+		set(OPENEXR_LIBPATH ${OPENEXR}/lib)
+		set(OPENEXR_LIBRARIES
+			optimized ${OPENEXR_LIBPATH}/Iex-2_2.lib
+			optimized ${OPENEXR_LIBPATH}/Half.lib
+			optimized ${OPENEXR_LIBPATH}/IlmImf-2_2.lib
+			optimized ${OPENEXR_LIBPATH}/Imath-2_2.lib
+			optimized ${OPENEXR_LIBPATH}/IlmThread-2_2.lib
+			debug ${OPENEXR_LIBPATH}/Iex-2_2_d.lib
+			debug ${OPENEXR_LIBPATH}/Half_d.lib
+			debug ${OPENEXR_LIBPATH}/IlmImf-2_2_d.lib
+			debug ${OPENEXR_LIBPATH}/Imath-2_2_d.lib
+			debug ${OPENEXR_LIBPATH}/IlmThread-2_2_d.lib
+		)
+	endif()
+endif()
+
+if(WITH_IMAGE_TIFF)
+	# Try to find tiff first then complain and set static and maybe wrong paths
+	find_package(TIFF)
+	if(NOT TIFF_FOUND)
+		message(WARNING "Using HARDCODED libtiff locations")
+		set(TIFF_LIBRARY ${LIBDIR}/tiff/lib/libtiff.lib)
+		set(TIFF_INCLUDE_DIR ${LIBDIR}/tiff/include)
+	endif()
+endif()
+
+if(WITH_JACK)
+	set(JACK_INCLUDE_DIRS
+		${LIBDIR}/jack/include/jack
+		${LIBDIR}/jack/include
+	)
+	set(JACK_LIBRARIES optimized ${LIBDIR}/jack/lib/libjack.lib debug ${LIBDIR}/jack/lib/libjack_d.lib)
+endif()
+
+if(WITH_PYTHON)
+	set(PYTHON_VERSION 3.5) # CACHE STRING)
+
+	string(REPLACE "." "" _PYTHON_VERSION_NO_DOTS ${PYTHON_VERSION})
+	# Use shared libs for vc2008 and vc2010 until we actually have vc2010 libs
+	set(PYTHON_LIBRARY ${LIBDIR}/python/lib/python${_PYTHON_VERSION_NO_DOTS}.lib)
+	unset(_PYTHON_VERSION_NO_DOTS)
+
+	# Shared includes for both vc2008 and vc2010
+	set(PYTHON_INCLUDE_DIR ${LIBDIR}/python/include/python${PYTHON_VERSION})
+
+	# uncached vars
+	set(PYTHON_INCLUDE_DIRS "${PYTHON_INCLUDE_DIR}")
+	set(PYTHON_LIBRARIES  "${PYTHON_LIBRARY}")
+endif()
+
+if(WITH_BOOST)
+	if(WITH_CYCLES_OSL)
+		set(boost_extra_libs wave)
+	endif()
+	if(WITH_INTERNATIONAL)
+		list(APPEND boost_extra_libs locale)
+	endif()
+	if(WITH_OPENVDB)
+		list(APPEND boost_extra_libs iostreams)
+	endif()
+	set(Boost_USE_STATIC_RUNTIME ON) # prefix lib
+	set(Boost_USE_MULTITHREADED ON) # suffix -mt
+	set(Boost_USE_STATIC_LIBS ON) # suffix -s
+	find_package(Boost COMPONENTS date_time filesystem thread regex system ${boost_extra_libs})
+	if(NOT Boost_FOUND)
+		message(WARNING "USING HARDCODED boost locations")
+		set(BOOST ${LIBDIR}/boost)
+		set(BOOST_INCLUDE_DIR ${BOOST}/include)
+		if(MSVC12)
+			set(BOOST_LIBPATH ${BOOST}/lib)
+			set(BOOST_POSTFIX "vc120-mt-s-1_60.lib")
+			set(BOOST_DEBUG_POSTFIX "vc120-mt-sgd-1_60.lib")
+		else()
+			set(BOOST_LIBPATH ${BOOST}/lib)
+			set(BOOST_POSTFIX "vc140-mt-s-1_60.lib")
+			set(BOOST_DEBUG_POSTFIX "vc140-mt-sgd-1_60.lib")
+		endif()
+		set(BOOST_LIBRARIES
+			optimized libboost_date_time-${BOOST_POSTFIX}
+			optimized libboost_filesystem-${BOOST_POSTFIX}
+			optimized libboost_regex-${BOOST_POSTFIX}
+			optimized libboost_system-${BOOST_POSTFIX}
+			optimized libboost_thread-${BOOST_POSTFIX}
+			debug libboost_date_time-${BOOST_DEBUG_POSTFIX}
+			debug libboost_filesystem-${BOOST_DEBUG_POSTFIX}
+			debug libboost_regex-${BOOST_DEBUG_POSTFIX}
+			debug libboost_system-${BOOST_DEBUG_POSTFIX}
+			debug libboost_thread-${BOOST_DEBUG_POSTFIX}
+		)
+		if(WITH_CYCLES_OSL)
+			set(BOOST_LIBRARIES ${BOOST_LIBRARIES}
+				optimized libboost_wave-${BOOST_POSTFIX}
+				debug libboost_wave-${BOOST_DEBUG_POSTFIX})
+		endif()
+		if(WITH_INTERNATIONAL)
+			set(BOOST_LIBRARIES ${BOOST_LIBRARIES}
+				optimized libboost_locale-${BOOST_POSTFIX}
+				debug libboost_locale-${BOOST_DEBUG_POSTFIX})
+		endif()
+	else() # we found boost using find_package
+		set(BOOST_INCLUDE_DIR ${Boost_INCLUDE_DIRS})
+		set(BOOST_LIBRARIES ${Boost_LIBRARIES})
+		set(BOOST_LIBPATH ${Boost_LIBRARY_DIRS})
+	endif()
+	set(BOOST_DEFINITIONS "-DBOOST_ALL_NO_LIB")
+endif()
+
+if(WITH_OPENIMAGEIO)
+	find_package(OpenImageIO)
+	set(OPENIMAGEIO ${LIBDIR}/openimageio)
+	set(OPENIMAGEIO_INCLUDE_DIRS ${OPENIMAGEIO}/include)
+	set(OIIO_OPTIMIZED optimized OpenImageIO optimized OpenImageIO_Util)
+	set(OIIO_DEBUG debug OpenImageIO_d debug OpenImageIO_Util_d)
+	set(OPENIMAGEIO_LIBRARIES ${OIIO_OPTIMIZED} ${OIIO_DEBUG})
+	set(OPENIMAGEIO_LIBPATH ${OPENIMAGEIO}/lib)
+	set(OPENIMAGEIO_DEFINITIONS "-DUSE_TBB=0")
+	set(OPENCOLORIO_DEFINITIONS "-DOCIO_STATIC_BUILD")
+	set(OPENIMAGEIO_IDIFF "${OPENIMAGEIO}/bin/idiff.exe")
+	add_definitions(-DOIIO_STATIC_BUILD)
+endif()
+
+if(WITH_LLVM)
+	set(LLVM_ROOT_DIR ${LIBDIR}/llvm CACHE PATH	"Path to the LLVM installation")
+	file(GLOB LLVM_LIBRARY_OPTIMIZED ${LLVM_ROOT_DIR}/lib/*.lib)
+
+	if(EXISTS ${LLVM_ROOT_DIR}/debug/lib)
+		foreach(LLVM_OPTIMIZED_LIB ${LLVM_LIBRARY_OPTIMIZED})
+			get_filename_component(LIBNAME ${LLVM_OPTIMIZED_LIB} ABSOLUTE)
+			list(APPEND LLVM_LIBS optimized ${LIBNAME})
+		endforeach(LLVM_OPTIMIZED_LIB)
+
+		file(GLOB LLVM_LIBRARY_DEBUG ${LLVM_ROOT_DIR}/debug/lib/*.lib)
+
+		foreach(LLVM_DEBUG_LIB ${LLVM_LIBRARY_DEBUG})
+			get_filename_component(LIBNAME ${LLVM_DEBUG_LIB} ABSOLUTE)
+			list(APPEND LLVM_LIBS debug ${LIBNAME})
+		endforeach(LLVM_DEBUG_LIB)
+
+		set(LLVM_LIBRARY ${LLVM_LIBS})
+	else()
+		message(WARNING "LLVM debug libs not present on this system. Using release libs for debug builds.")
+		set(LLVM_LIBRARY ${LLVM_LIBRARY_OPTIMIZED})
+	endif()
+
+endif()
+
+if(WITH_OPENCOLORIO)
+	set(OPENCOLORIO ${LIBDIR}/opencolorio)
+	set(OPENCOLORIO_INCLUDE_DIRS ${OPENCOLORIO}/include)
+	set(OPENCOLORIO_LIBRARIES OpenColorIO)
+	set(OPENCOLORIO_LIBPATH ${LIBDIR}/opencolorio/lib)
+	set(OPENCOLORIO_DEFINITIONS)
+endif()
+
+if(WITH_OPENVDB)
+	set(BLOSC_LIBRARIES optimized ${LIBDIR}/blosc/lib/libblosc.lib debug ${LIBDIR}/blosc/lib/libblosc_d.lib)
+	set(TBB_LIBRARIES optimized ${LIBDIR}/tbb/lib/tbb.lib debug ${LIBDIR}/tbb/lib/tbb_debug.lib)
+	set(TBB_INCLUDE_DIR ${LIBDIR}/tbb/include)
+	set(OPENVDB ${LIBDIR}/openvdb)
+	set(OPENVDB_INCLUDE_DIRS ${OPENVDB}/include ${TBB_INCLUDE_DIR})
+	set(OPENVDB_LIBRARIES optimized openvdb debug openvdb_d ${TBB_LIBRARIES} ${BLOSC_LIBRARIES})
+	set(OPENVDB_LIBPATH ${LIBDIR}/openvdb/lib)
+endif()
+
+if(WITH_ALEMBIC)
+	set(ALEMBIC ${LIBDIR}/alembic)
+	set(ALEMBIC_INCLUDE_DIR ${ALEMBIC}/include)
+	set(ALEMBIC_INCLUDE_DIRS ${ALEMBIC_INCLUDE_DIR})
+	set(ALEMBIC_LIBPATH ${ALEMBIC}/lib)
+	set(ALEMBIC_LIBRARIES optimized alembic debug alembic_d)
+endif()
+
+if(WITH_MOD_CLOTH_ELTOPO)
+	set(LAPACK ${LIBDIR}/lapack)
+	# set(LAPACK_INCLUDE_DIR ${LAPACK}/include)
+	set(LAPACK_LIBPATH ${LAPACK}/lib)
+	set(LAPACK_LIBRARIES
+		${LIBDIR}/lapack/lib/libf2c.lib
+		${LIBDIR}/lapack/lib/clapack_nowrap.lib
+		${LIBDIR}/lapack/lib/BLAS_nowrap.lib
+	)
+endif()
+
+if(WITH_OPENSUBDIV)
+	set(OPENSUBDIV_INCLUDE_DIR ${LIBDIR}/opensubdiv/include)
+	set(OPENSUBDIV_LIBPATH ${LIBDIR}/opensubdiv/lib)
+	set(OPENSUBDIV_LIBRARIES ${OPENSUBDIV_LIBPATH}/osdCPU.lib ${OPENSUBDIV_LIBPATH}/osdGPU.lib)
+	find_package(OpenSubdiv)
+endif()
+
+if(WITH_SDL)
+	set(SDL ${LIBDIR}/sdl)
+	set(SDL_INCLUDE_DIR ${SDL}/include)
+	set(SDL_LIBPATH ${SDL}/lib)
+	# MinGW TODO: Update MinGW to SDL2
+	if(NOT CMAKE_COMPILER_IS_GNUCC)
+		set(SDL_LIBRARY SDL2)
+	else()
+		set(SDL_LIBRARY SDL)
+	endif()
+endif()
+
+# Audio IO
+if(WITH_SYSTEM_AUDASPACE)
+	set(AUDASPACE_INCLUDE_DIRS ${LIBDIR}/audaspace/include/audaspace)
+	set(AUDASPACE_LIBRARIES ${LIBDIR}/audaspace/lib/audaspace.lib)
+	set(AUDASPACE_C_INCLUDE_DIRS ${LIBDIR}/audaspace/include/audaspace)
+	set(AUDASPACE_C_LIBRARIES ${LIBDIR}/audaspace/lib/audaspace-c.lib)
+	set(AUDASPACE_PY_INCLUDE_DIRS ${LIBDIR}/audaspace/include/audaspace)
+	set(AUDASPACE_PY_LIBRARIES ${LIBDIR}/audaspace/lib/audaspace-py.lib)
+endif()
+
+# used in many places so include globally, like OpenGL
+blender_include_dirs_sys("${PTHREADS_INCLUDE_DIRS}")

intern/cycles/app/CMakeLists.txt

@@ -88,6 +88,9 @@ macro(cycles_target_link_libraries target)
 	if(WITH_CYCLES_OSL)
 		target_link_libraries(${target} ${OSL_LIBRARIES} ${LLVM_LIBRARIES})
 	endif()
+	if(WITH_CYCLES_OPENSUBDIV)
+		target_link_libraries(${target} ${OPENSUBDIV_LIBRARIES})
+	endif()
 	target_link_libraries(
 		${target}
 		${OPENIMAGEIO_LIBRARIES}

intern/cycles/app/cycles_standalone.cpp

@@ -375,6 +375,8 @@ static void options_parse(int argc, const char **argv)
 		"--threads %d", &options.session_params.threads, "CPU Rendering Threads",
 		"--width  %d", &options.width, "Window width in pixel",
 		"--height %d", &options.height, "Window height in pixel",
+		"--tile-width %d", &options.session_params.tile_size.x, "Tile width in pixels",
+		"--tile-height %d", &options.session_params.tile_size.y, "Tile height in pixels",
 		"--list-devices", &list, "List information about all available devices",
 #ifdef WITH_CYCLES_LOGGING
 		"--debug", &debug, "Enable debug logging",

intern/cycles/app/cycles_xml.cpp

@@ -57,14 +57,12 @@ struct XMLReadState : public XMLReader {
 	Shader *shader;		/* current shader */
 	string base;		/* base path to current file*/
 	float dicing_rate;	/* current dicing rate */
-	Mesh::DisplacementMethod displacement_method;
 
 	XMLReadState()
 	  : scene(NULL),
 	    smooth(false),
 	    shader(NULL),
-	    dicing_rate(0.0f),
-	    displacement_method(Mesh::DISPLACE_BUMP)
+	    dicing_rate(0.0f)
 	{
 		tfm = transform_identity();
 	}
@@ -405,8 +403,6 @@ static void xml_read_mesh(const XMLReadState& state, pugi::xml_node node)
 	int shader = 0;
 	bool smooth = state.smooth;
 
-	mesh->displacement_method = state.displacement_method;
-
 	/* read vertices and polygons, RIB style */
 	vector<float3> P;
 	vector<float> UV;
@@ -653,14 +649,6 @@ static void xml_read_state(XMLReadState& state, pugi::xml_node node)
 		state.smooth = true;
 	else if(xml_equal_string(node, "interpolation", "flat"))
 		state.smooth = false;
-
-	/* read displacement method */
-	if(xml_equal_string(node, "displacement_method", "true"))
-		state.displacement_method = Mesh::DISPLACE_TRUE;
-	else if(xml_equal_string(node, "displacement_method", "bump"))
-		state.displacement_method = Mesh::DISPLACE_BUMP;
-	else if(xml_equal_string(node, "displacement_method", "both"))
-		state.displacement_method = Mesh::DISPLACE_BOTH;
 }
 
 /* Scene */

intern/cycles/blender/blender_mesh.cpp

@@ -806,7 +806,10 @@ static void create_subd_mesh(Scene *scene,
 	}
 
 	/* set subd params */
-	SubdParams sdparams(mesh);
+	if(!mesh->subd_params) {
+		mesh->subd_params = new SubdParams(mesh);
+	}
+	SubdParams& sdparams = *mesh->subd_params;
 
 	PointerRNA cobj = RNA_pointer_get(&b_ob.ptr, "cycles");
 
@@ -816,10 +819,6 @@ static void create_subd_mesh(Scene *scene,
 	scene->camera->update();
 	sdparams.camera = scene->camera;
 	sdparams.objecttoworld = get_transform(b_ob.matrix_world());
-
-	/* tesselate */
-	DiagSplit dsplit(sdparams);
-	mesh->tessellate(&dsplit);
 }
 
 /* Sync */

intern/cycles/blender/blender_util.h

@@ -698,7 +698,7 @@ protected:
 
 /* Object Key */
 
-enum { OBJECT_PERSISTENT_ID_SIZE = 8 };
+enum { OBJECT_PERSISTENT_ID_SIZE = 16 };
 
 struct ObjectKey {
 	void *parent;

intern/cycles/bvh/bvh_build.cpp

@@ -713,14 +713,14 @@ BVHNode* BVHBuild::create_leaf_node(const BVHRange& range,
 	 *    can not control.
 	 */
 	typedef StackAllocator<256, int> LeafStackAllocator;
+	typedef StackAllocator<256, BVHReference> LeafReferenceStackAllocator;
 
 	vector<int, LeafStackAllocator> p_type[PRIMITIVE_NUM_TOTAL];
 	vector<int, LeafStackAllocator> p_index[PRIMITIVE_NUM_TOTAL];
 	vector<int, LeafStackAllocator> p_object[PRIMITIVE_NUM_TOTAL];
-	vector<BVHReference, LeafStackAllocator> p_ref[PRIMITIVE_NUM_TOTAL];
+	vector<BVHReference, LeafReferenceStackAllocator> p_ref[PRIMITIVE_NUM_TOTAL];
 
 	/* TODO(sergey): In theory we should be able to store references. */
-	typedef StackAllocator<256, BVHReference> LeafReferenceStackAllocator;
 	vector<BVHReference, LeafReferenceStackAllocator> object_references;
 
 	uint visibility[PRIMITIVE_NUM_TOTAL] = {0};

intern/cycles/device/device.cpp

@@ -56,8 +56,14 @@ std::ostream& operator <<(std::ostream &os,
 	   << string_from_bool(requested_features.use_camera_motion)  << std::endl;
 	os << "Use Baking: "
 	   << string_from_bool(requested_features.use_baking)  << std::endl;
+	os << "Use Subsurface: "
+	   << string_from_bool(requested_features.use_subsurface) << std::endl;
 	os << "Use Volume: "
 	   << string_from_bool(requested_features.use_volume)  << std::endl;
+	os << "Use Branched Integrator: "
+	   << string_from_bool(requested_features.use_integrator_branched) << std::endl;
+	os << "Use Patch Evaluation: "
+	   << string_from_bool(requested_features.use_patch_evaluation) << std::endl;
 	return os;
 }
 

intern/cycles/device/device.h

@@ -109,6 +109,9 @@ public:
 	/* Use branched integrator. */
 	bool use_integrator_branched;
 
+	/* Use OpenSubdiv patch evaluation */
+	bool use_patch_evaluation;
+
 	DeviceRequestedFeatures()
 	{
 		/* TODO(sergey): Find more meaningful defaults. */
@@ -123,6 +126,7 @@ public:
 		use_subsurface = false;
 		use_volume = false;
 		use_integrator_branched = false;
+		use_patch_evaluation = false;
 	}
 
 	bool modified(const DeviceRequestedFeatures& requested_features)
@@ -137,7 +141,8 @@ public:
 		         use_baking == requested_features.use_baking &&
 		         use_subsurface == requested_features.use_subsurface &&
 		         use_volume == requested_features.use_volume &&
-		         use_integrator_branched == requested_features.use_integrator_branched);
+		         use_integrator_branched == requested_features.use_integrator_branched &&
+		         use_patch_evaluation == requested_features.use_patch_evaluation);
 	}
 
 	/* Convert the requested features structure to a build options,
@@ -175,6 +180,9 @@ public:
 		if(!use_integrator_branched) {
 			build_options += " -D__NO_BRANCHED_PATH__";
 		}
+		if(!use_patch_evaluation) {
+			build_options += " -D__NO_PATCH_EVAL__";
+		}
 		return build_options;
 	}
 };

intern/cycles/device/device_cuda.cpp

@@ -576,6 +576,7 @@ public:
 			case TYPE_UINT: format = CU_AD_FORMAT_UNSIGNED_INT32; break;
 			case TYPE_INT: format = CU_AD_FORMAT_SIGNED_INT32; break;
 			case TYPE_FLOAT: format = CU_AD_FORMAT_FLOAT; break;
+			case TYPE_HALF: format = CU_AD_FORMAT_HALF; break;
 			default: assert(0); return;
 		}
 
@@ -747,8 +748,12 @@ public:
 				}
 
 				/* Resize once */
-				if(flat_slot >= bindless_mapping.size())
-					bindless_mapping.resize(4096); /*TODO(dingto): Make this a variable */
+				if(flat_slot >= bindless_mapping.size()) {
+					/* Allocate some slots in advance, to reduce amount
+					 * of re-allocations.
+					 */
+					bindless_mapping.resize(flat_slot + 128);
+				}
 
 				/* Set Mapping and tag that we need to (re-)upload to device */
 				bindless_mapping.get_data()[flat_slot] = (uint)tex;

intern/cycles/kernel/CMakeLists.txt

@@ -176,6 +176,7 @@ set(SRC_UTIL_HEADERS
 	../util/util_half.h
 	../util/util_math.h
 	../util/util_math_fast.h
+	../util/util_static_assert.h
 	../util/util_transform.h
 	../util/util_texture.h
 	../util/util_types.h

intern/cycles/kernel/geom/geom.h

@@ -17,7 +17,9 @@
 
 #include "geom_attribute.h"
 #include "geom_object.h"
-#include "geom_patch.h"
+#ifdef __PATCH_EVAL__
+#  include "geom_patch.h"
+#endif
 #include "geom_triangle.h"
 #include "geom_subd_triangle.h"
 #include "geom_triangle_intersect.h"

intern/cycles/kernel/geom/geom_attribute.h

@@ -73,7 +73,11 @@ ccl_device_inline AttributeDescriptor find_attribute(KernelGlobals *kg, const Sh
 	AttributeDescriptor desc;
 	desc.element = (AttributeElement)attr_map.y;
 	
-	if(ccl_fetch(sd, prim) == PRIM_NONE && desc.element != ATTR_ELEMENT_MESH) {
+	if(ccl_fetch(sd, prim) == PRIM_NONE &&
+	   desc.element != ATTR_ELEMENT_MESH &&
+	   desc.element != ATTR_ELEMENT_VOXEL &&
+	   desc.element != ATTR_ELEMENT_OBJECT)
+	{
 		return attribute_not_found();
 	}
 

intern/cycles/kernel/geom/geom_subd_triangle.h

@@ -101,6 +101,7 @@ ccl_device_noinline float subd_triangle_attribute_float(KernelGlobals *kg, const
 {
 	int patch = subd_triangle_patch(kg, sd);
 
+#ifdef __PATCH_EVAL__
 	if(desc.flags & ATTR_SUBDIVIDED) {
 		float2 uv[3];
 		subd_triangle_patch_uv(kg, sd, uv);
@@ -144,7 +145,9 @@ ccl_device_noinline float subd_triangle_attribute_float(KernelGlobals *kg, const
 
 		return a;
 	}
-	else if(desc.element == ATTR_ELEMENT_FACE) {
+	else
+#endif /* __PATCH_EVAL__ */
+	if(desc.element == ATTR_ELEMENT_FACE) {
 		if(dx) *dx = 0.0f;
 		if(dy) *dy = 0.0f;
 
@@ -217,6 +220,7 @@ ccl_device_noinline float3 subd_triangle_attribute_float3(KernelGlobals *kg, con
 {
 	int patch = subd_triangle_patch(kg, sd);
 
+#ifdef __PATCH_EVAL__
 	if(desc.flags & ATTR_SUBDIVIDED) {
 		float2 uv[3];
 		subd_triangle_patch_uv(kg, sd, uv);
@@ -266,7 +270,9 @@ ccl_device_noinline float3 subd_triangle_attribute_float3(KernelGlobals *kg, con
 
 		return a;
 	}
-	else if(desc.element == ATTR_ELEMENT_FACE) {
+	else
+#endif /* __PATCH_EVAL__ */
+	if(desc.element == ATTR_ELEMENT_FACE) {
 		if(dx) *dx = make_float3(0.0f, 0.0f, 0.0f);
 		if(dy) *dy = make_float3(0.0f, 0.0f, 0.0f);
 

intern/cycles/kernel/kernel_compat_cpu.h

@@ -495,6 +495,7 @@ typedef texture<uint> texture_uint;
 typedef texture<int> texture_int;
 typedef texture<uint4> texture_uint4;
 typedef texture<uchar4> texture_uchar4;
+typedef texture<uchar> texture_uchar;
 typedef texture_image<float> texture_image_float;
 typedef texture_image<uchar> texture_image_uchar;
 typedef texture_image<half> texture_image_half;

intern/cycles/kernel/kernel_compat_cuda.h

@@ -31,6 +31,7 @@
 #endif
 
 #include <cuda.h>
+#include <cuda_fp16.h>
 #include <float.h>
 
 /* Qualifier wrappers for different names on different devices */
@@ -66,6 +67,7 @@ typedef texture<float, 1> texture_float;
 typedef texture<uint, 1> texture_uint;
 typedef texture<int, 1> texture_int;
 typedef texture<uint4, 1> texture_uint4;
+typedef texture<uchar, 1> texture_uchar;
 typedef texture<uchar4, 1> texture_uchar4;
 typedef texture<float4, 2> texture_image_float4;
 typedef texture<float4, 3> texture_image3d_float4;

intern/cycles/kernel/kernel_textures.h

@@ -188,6 +188,8 @@ KERNEL_TEX(uint, texture_uint, __bindless_mapping)
 /* packed image (opencl) */
 KERNEL_TEX(uchar4, texture_uchar4, __tex_image_byte4_packed)
 KERNEL_TEX(float4, texture_float4, __tex_image_float4_packed)
+KERNEL_TEX(uchar, texture_uchar, __tex_image_byte_packed)
+KERNEL_TEX(float, texture_float, __tex_image_float_packed)
 KERNEL_TEX(uint4, texture_uint4, __tex_image_packed_info)
 
 #undef KERNEL_TEX

intern/cycles/kernel/kernel_types.h

@@ -19,6 +19,7 @@
 
 #include "kernel_math.h"
 #include "svm/svm_types.h"
+#include "util_static_assert.h"
 
 #ifndef __KERNEL_GPU__
 #  define __KERNEL_CPU__
@@ -147,6 +148,7 @@ CCL_NAMESPACE_BEGIN
 #define __CAMERA_CLIPPING__
 #define __INTERSECTION_REFINE__
 #define __CLAMP_SAMPLE__
+#define __PATCH_EVAL__
 
 #ifdef __KERNEL_SHADING__
 #  define __SVM__
@@ -196,6 +198,9 @@ CCL_NAMESPACE_BEGIN
 #ifdef __NO_BRANCHED_PATH__
 #  undef __BRANCHED_PATH__
 #endif
+#ifdef __NO_PATCH_EVAL__
+#  undef __PATCH_EVAL__
+#endif
 
 /* Random Numbers */
 
@@ -986,6 +991,7 @@ typedef struct KernelCamera {
 
 	int pad;
 } KernelCamera;
+static_assert_align(KernelCamera, 16);
 
 typedef struct KernelFilm {
 	float exposure;
@@ -1040,6 +1046,7 @@ typedef struct KernelFilm {
 	int pass_pad3;
 #endif
 } KernelFilm;
+static_assert_align(KernelFilm, 16);
 
 typedef struct KernelBackground {
 	/* only shader index */
@@ -1053,6 +1060,7 @@ typedef struct KernelBackground {
 	float ao_distance;
 	float ao_pad1, ao_pad2;
 } KernelBackground;
+static_assert_align(KernelBackground, 16);
 
 typedef struct KernelIntegrator {
 	/* emission */
@@ -1120,8 +1128,10 @@ typedef struct KernelIntegrator {
 	float volume_step_size;
 	int volume_samples;
 
-	int pad;
+	int pad1;
+	int pad2;
 } KernelIntegrator;
+static_assert_align(KernelIntegrator, 16);
 
 typedef struct KernelBVH {
 	/* root node */
@@ -1133,6 +1143,7 @@ typedef struct KernelBVH {
 	int use_qbvh;
 	int pad1, pad2;
 } KernelBVH;
+static_assert_align(KernelBVH, 16);
 
 typedef enum CurveFlag {
 	/* runtime flags */
@@ -1152,11 +1163,13 @@ typedef struct KernelCurves {
 	float minimum_width;
 	float maximum_width;
 } KernelCurves;
+static_assert_align(KernelCurves, 16);
 
 typedef struct KernelTables {
 	int beckmann_offset;
 	int pad1, pad2, pad3;
 } KernelTables;
+static_assert_align(KernelTables, 16);
 
 typedef struct KernelData {
 	KernelCamera cam;
@@ -1167,8 +1180,12 @@ typedef struct KernelData {
 	KernelCurves curve;
 	KernelTables tables;
 } KernelData;
+static_assert_align(KernelData, 16);
 
 #ifdef __KERNEL_DEBUG__
+/* NOTE: This is a runtime-only struct, alignment is not
+ * really important here.
+ */
 typedef ccl_addr_space struct DebugData {
 	// Total number of BVH node traversal steps and primitives intersections
 	// for the camera rays.
@@ -1253,7 +1270,7 @@ enum RayState {
 /* Patch map node flags */
 
 #define PATCH_MAP_NODE_IS_SET (1 << 30)
-#define PATCH_MAP_NODE_IS_LEAF (1 << 31)
+#define PATCH_MAP_NODE_IS_LEAF (1u << 31)
 #define PATCH_MAP_NODE_INDEX_MASK (~(PATCH_MAP_NODE_IS_SET | PATCH_MAP_NODE_IS_LEAF))
 
 CCL_NAMESPACE_END

intern/cycles/kernel/kernels/cpu/kernel_cpu_image.h

@@ -25,12 +25,12 @@ ccl_device float4 kernel_tex_image_interp_impl(KernelGlobals *kg, int tex, float
 {
 	if(tex >= TEX_START_HALF_CPU)
 		return kg->texture_half_images[tex - TEX_START_HALF_CPU].interp(x, y);
-	else if(tex >= TEX_START_HALF4_CPU)
-		return kg->texture_half4_images[tex - TEX_START_HALF4_CPU].interp(x, y);
 	else if(tex >= TEX_START_BYTE_CPU)
 		return kg->texture_byte_images[tex - TEX_START_BYTE_CPU].interp(x, y);
 	else if(tex >= TEX_START_FLOAT_CPU)
 		return kg->texture_float_images[tex - TEX_START_FLOAT_CPU].interp(x, y);
+	else if(tex >= TEX_START_HALF4_CPU)
+		return kg->texture_half4_images[tex - TEX_START_HALF4_CPU].interp(x, y);
 	else if(tex >= TEX_START_BYTE4_CPU)
 		return kg->texture_byte4_images[tex - TEX_START_BYTE4_CPU].interp(x, y);
 	else
@@ -41,12 +41,12 @@ ccl_device float4 kernel_tex_image_interp_3d_impl(KernelGlobals *kg, int tex, fl
 {
 	if(tex >= TEX_START_HALF_CPU)
 		return kg->texture_half_images[tex - TEX_START_HALF_CPU].interp_3d(x, y, z);
-	else if(tex >= TEX_START_HALF4_CPU)
-		return kg->texture_half4_images[tex - TEX_START_HALF4_CPU].interp_3d(x, y, z);
 	else if(tex >= TEX_START_BYTE_CPU)
 		return kg->texture_byte_images[tex - TEX_START_BYTE_CPU].interp_3d(x, y, z);
 	else if(tex >= TEX_START_FLOAT_CPU)
 		return kg->texture_float_images[tex - TEX_START_FLOAT_CPU].interp_3d(x, y, z);
+	else if(tex >= TEX_START_HALF4_CPU)
+		return kg->texture_half4_images[tex - TEX_START_HALF4_CPU].interp_3d(x, y, z);
 	else if(tex >= TEX_START_BYTE4_CPU)
 		return kg->texture_byte4_images[tex - TEX_START_BYTE4_CPU].interp_3d(x, y, z);
 	else
@@ -57,13 +57,13 @@ ccl_device float4 kernel_tex_image_interp_3d_impl(KernelGlobals *kg, int tex, fl
 ccl_device float4 kernel_tex_image_interp_3d_ex_impl(KernelGlobals *kg, int tex, float x, float y, float z, int interpolation)
 {
 	if(tex >= TEX_START_HALF_CPU)
-		return kg->texture_half4_images[tex - TEX_START_HALF_CPU].interp_3d_ex(x, y, z, interpolation);
-	else if(tex >= TEX_START_HALF4_CPU)
-		return kg->texture_half_images[tex - TEX_START_HALF4_CPU].interp_3d_ex(x, y, z, interpolation);
+		return kg->texture_half_images[tex - TEX_START_HALF_CPU].interp_3d_ex(x, y, z, interpolation);
 	else if(tex >= TEX_START_BYTE_CPU)
 		return kg->texture_byte_images[tex - TEX_START_BYTE_CPU].interp_3d_ex(x, y, z, interpolation);
 	else if(tex >= TEX_START_FLOAT_CPU)
 		return kg->texture_float_images[tex - TEX_START_FLOAT_CPU].interp_3d_ex(x, y, z, interpolation);
+	else if(tex >= TEX_START_HALF4_CPU)
+		return kg->texture_half4_images[tex - TEX_START_HALF4_CPU].interp_3d_ex(x, y, z, interpolation);
 	else if(tex >= TEX_START_BYTE4_CPU)
 		return kg->texture_byte4_images[tex - TEX_START_BYTE4_CPU].interp_3d_ex(x, y, z, interpolation);
 	else

intern/cycles/kernel/shaders/node_rgb_curves.osl

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "stdosl.h"
 #include "node_ramp_util.h"
 
 shader node_rgb_curves(

intern/cycles/kernel/shaders/node_rgb_ramp.osl

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "stdosl.h"
 #include "node_ramp_util.h"
 
 shader node_rgb_ramp(

intern/cycles/kernel/shaders/node_vector_curves.osl

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "stdosl.h"
 #include "node_ramp_util.h"
 
 shader node_vector_curves(

intern/cycles/kernel/svm/svm_image.h

@@ -18,7 +18,7 @@ CCL_NAMESPACE_BEGIN
 
 /* Float4 textures on various devices. */
 #if defined(__KERNEL_CPU__)
-#  define TEX_NUM_FLOAT4_IMAGES	TEX_NUM_FLOAT4_CPU
+#  define TEX_NUM_FLOAT4_IMAGES		TEX_NUM_FLOAT4_CPU
 #elif defined(__KERNEL_CUDA__)
 #  if __CUDA_ARCH__ < 300
 #    define TEX_NUM_FLOAT4_IMAGES	TEX_NUM_FLOAT4_CUDA
@@ -36,13 +36,26 @@ CCL_NAMESPACE_BEGIN
 
 ccl_device_inline float4 svm_image_texture_read(KernelGlobals *kg, int id, int offset)
 {
-	if(id >= TEX_NUM_FLOAT4_IMAGES) {
+	/* Float4 */
+	if(id < TEX_START_BYTE4_OPENCL) {
+		return kernel_tex_fetch(__tex_image_float4_packed, offset);
+	}
+	/* Byte4 */
+	else if(id < TEX_START_FLOAT_OPENCL) {
 		uchar4 r = kernel_tex_fetch(__tex_image_byte4_packed, offset);
 		float f = 1.0f/255.0f;
 		return make_float4(r.x*f, r.y*f, r.z*f, r.w*f);
 	}
+	/* Float */
+	else if(id < TEX_START_BYTE_OPENCL) {
+		float f = kernel_tex_fetch(__tex_image_float_packed, offset);
+		return make_float4(f, f, f, 1.0f);
+	}
+	/* Byte */
 	else {
-		return kernel_tex_fetch(__tex_image_float4_packed, offset);
+		uchar r = kernel_tex_fetch(__tex_image_byte_packed, offset);
+		float f = r * (1.0f/255.0f);
+		return make_float4(f, f, f, 1.0f);
 	}
 }
 
@@ -277,8 +290,10 @@ ccl_device float4 svm_image_texture(KernelGlobals *kg, int id, float x, float y,
 	}
 #  else
 	CUtexObject tex = kernel_tex_fetch(__bindless_mapping, id);
-	if(id < 2048) /* TODO(dingto): Make this a variable */
+	/* float4, byte4 and half4 */
+	if(id < TEX_START_FLOAT_CUDA_KEPLER)
 		r = kernel_tex_image_interp_float4(tex, x, y);
+	/* float, byte and half */
 	else {
 		float f = kernel_tex_image_interp_float(tex, x, y);
 		r = make_float4(f, f, f, 1.0);

intern/cycles/render/image.cpp

@@ -52,15 +52,15 @@ ImageManager::ImageManager(const DeviceInfo& info)
 	{ \
 		tex_num_images[IMAGE_DATA_TYPE_FLOAT4] = TEX_NUM_FLOAT4_ ## ARCH; \
 		tex_num_images[IMAGE_DATA_TYPE_BYTE4] = TEX_NUM_BYTE4_ ## ARCH; \
+		tex_num_images[IMAGE_DATA_TYPE_HALF4] = TEX_NUM_HALF4_ ## ARCH; \
 		tex_num_images[IMAGE_DATA_TYPE_FLOAT] = TEX_NUM_FLOAT_ ## ARCH; \
 		tex_num_images[IMAGE_DATA_TYPE_BYTE] = TEX_NUM_BYTE_ ## ARCH; \
-		tex_num_images[IMAGE_DATA_TYPE_HALF4] = TEX_NUM_HALF4_ ## ARCH; \
 		tex_num_images[IMAGE_DATA_TYPE_HALF] = TEX_NUM_HALF_ ## ARCH; \
 		tex_start_images[IMAGE_DATA_TYPE_FLOAT4] = TEX_START_FLOAT4_ ## ARCH; \
 		tex_start_images[IMAGE_DATA_TYPE_BYTE4] = TEX_START_BYTE4_ ## ARCH; \
+		tex_start_images[IMAGE_DATA_TYPE_HALF4] = TEX_START_HALF4_ ## ARCH; \
 		tex_start_images[IMAGE_DATA_TYPE_FLOAT] = TEX_START_FLOAT_ ## ARCH; \
 		tex_start_images[IMAGE_DATA_TYPE_BYTE] = TEX_START_BYTE_ ## ARCH; \
-		tex_start_images[IMAGE_DATA_TYPE_HALF4] = TEX_START_HALF4_ ## ARCH; \
 		tex_start_images[IMAGE_DATA_TYPE_HALF] = TEX_START_HALF_ ## ARCH; \
 	}
 
@@ -82,15 +82,15 @@ ImageManager::ImageManager(const DeviceInfo& info)
 		/* Should not happen. */
 		tex_num_images[IMAGE_DATA_TYPE_FLOAT4] = 0;
 		tex_num_images[IMAGE_DATA_TYPE_BYTE4] = 0;
+		tex_num_images[IMAGE_DATA_TYPE_HALF4] = 0;
 		tex_num_images[IMAGE_DATA_TYPE_FLOAT] = 0;
 		tex_num_images[IMAGE_DATA_TYPE_BYTE] = 0;
-		tex_num_images[IMAGE_DATA_TYPE_HALF4] = 0;
 		tex_num_images[IMAGE_DATA_TYPE_HALF] = 0;
 		tex_start_images[IMAGE_DATA_TYPE_FLOAT4] = 0;
 		tex_start_images[IMAGE_DATA_TYPE_BYTE4] = 0;
+		tex_start_images[IMAGE_DATA_TYPE_HALF4] = 0;
 		tex_start_images[IMAGE_DATA_TYPE_FLOAT] = 0;
 		tex_start_images[IMAGE_DATA_TYPE_BYTE] = 0;
-		tex_start_images[IMAGE_DATA_TYPE_HALF4] = 0;
 		tex_start_images[IMAGE_DATA_TYPE_HALF] = 0;
 		assert(0);
 	}
@@ -216,7 +216,7 @@ ImageManager::ImageDataType ImageManager::get_image_metadata(const string& filen
 }
 
 /* We use a consecutive slot counting scheme on the devices, in order
- * float4, byte4, float, byte.
+ * float4, byte4, half4, float, byte, half.
  * These functions convert the slot ids from ImageManager "images" ones
  * to device ones and vice versa. */
 int ImageManager::type_index_to_flattened_slot(int slot, ImageDataType type)
@@ -284,7 +284,7 @@ int ImageManager::add_image(const string& filename,
 	if(type == IMAGE_DATA_TYPE_FLOAT || type == IMAGE_DATA_TYPE_FLOAT4)
 		is_float = true;
 
-	/* No single channel and half textures on CUDA (Fermi) and OpenCL, use available slots */
+	/* No single channel and half textures on CUDA (Fermi) and no half on OpenCL, use available slots */
 	if((type == IMAGE_DATA_TYPE_FLOAT ||
 	    type == IMAGE_DATA_TYPE_HALF4 ||
 	    type == IMAGE_DATA_TYPE_HALF) &&
@@ -1105,10 +1105,11 @@ void ImageManager::device_pack_images(Device *device,
 	size_t size = 0, offset = 0;
 	ImageDataType type;
 
-	int info_size = tex_num_images[IMAGE_DATA_TYPE_FLOAT4] + tex_num_images[IMAGE_DATA_TYPE_BYTE4];
+	int info_size = tex_num_images[IMAGE_DATA_TYPE_FLOAT4] + tex_num_images[IMAGE_DATA_TYPE_BYTE4]
+	                + tex_num_images[IMAGE_DATA_TYPE_FLOAT] + tex_num_images[IMAGE_DATA_TYPE_BYTE];
 	uint4 *info = dscene->tex_image_packed_info.resize(info_size);
 
-	/* Byte Textures*/
+	/* Byte4 Textures*/
 	type = IMAGE_DATA_TYPE_BYTE4;
 
 	for(size_t slot = 0; slot < images[type].size(); slot++) {
@@ -1119,7 +1120,7 @@ void ImageManager::device_pack_images(Device *device,
 		size += tex_img.size();
 	}
 
-	uchar4 *pixels_byte = dscene->tex_image_byte4_packed.resize(size);
+	uchar4 *pixels_byte4 = dscene->tex_image_byte4_packed.resize(size);
 
 	for(size_t slot = 0; slot < images[type].size(); slot++) {
 		if(!images[type][slot])
@@ -1131,11 +1132,11 @@ void ImageManager::device_pack_images(Device *device,
 
 		info[type_index_to_flattened_slot(slot, type)] = make_uint4(tex_img.data_width, tex_img.data_height, offset, options);
 
-		memcpy(pixels_byte+offset, (void*)tex_img.data_pointer, tex_img.memory_size());
+		memcpy(pixels_byte4+offset, (void*)tex_img.data_pointer, tex_img.memory_size());
 		offset += tex_img.size();
 	}
 
-	/* Float Textures*/
+	/* Float4 Textures*/
 	type = IMAGE_DATA_TYPE_FLOAT4;
 	size = 0, offset = 0;
 
@@ -1147,7 +1148,7 @@ void ImageManager::device_pack_images(Device *device,
 		size += tex_img.size();
 	}
 
-	float4 *pixels_float = dscene->tex_image_float4_packed.resize(size);
+	float4 *pixels_float4 = dscene->tex_image_float4_packed.resize(size);
 
 	for(size_t slot = 0; slot < images[type].size(); slot++) {
 		if(!images[type][slot])
@@ -1160,6 +1161,63 @@ void ImageManager::device_pack_images(Device *device,
 		uint8_t options = pack_image_options(type, slot);
 		info[type_index_to_flattened_slot(slot, type)] = make_uint4(tex_img.data_width, tex_img.data_height, offset, options);
 
+		memcpy(pixels_float4+offset, (void*)tex_img.data_pointer, tex_img.memory_size());
+		offset += tex_img.size();
+	}
+
+	/* Byte Textures*/
+	type = IMAGE_DATA_TYPE_BYTE;
+	size = 0, offset = 0;
+
+	for(size_t slot = 0; slot < images[type].size(); slot++) {
+		if(!images[type][slot])
+			continue;
+
+		device_vector<uchar>& tex_img = dscene->tex_byte_image[slot];
+		size += tex_img.size();
+	}
+
+	uchar *pixels_byte = dscene->tex_image_byte_packed.resize(size);
+
+	for(size_t slot = 0; slot < images[type].size(); slot++) {
+		if(!images[type][slot])
+			continue;
+
+		device_vector<uchar>& tex_img = dscene->tex_byte_image[slot];
+
+		uint8_t options = pack_image_options(type, slot);
+
+		info[type_index_to_flattened_slot(slot, type)] = make_uint4(tex_img.data_width, tex_img.data_height, offset, options);
+
+		memcpy(pixels_byte+offset, (void*)tex_img.data_pointer, tex_img.memory_size());
+		offset += tex_img.size();
+	}
+
+	/* Float Textures*/
+	type = IMAGE_DATA_TYPE_FLOAT;
+	size = 0, offset = 0;
+
+	for(size_t slot = 0; slot < images[type].size(); slot++) {
+		if(!images[type][slot])
+			continue;
+
+		device_vector<float>& tex_img = dscene->tex_float_image[slot];
+		size += tex_img.size();
+	}
+
+	float *pixels_float = dscene->tex_image_float_packed.resize(size);
+
+	for(size_t slot = 0; slot < images[type].size(); slot++) {
+		if(!images[type][slot])
+			continue;
+
+		device_vector<float>& tex_img = dscene->tex_float_image[slot];
+
+		/* todo: support 3D textures, only CPU for now */
+
+		uint8_t options = pack_image_options(type, slot);
+		info[type_index_to_flattened_slot(slot, type)] = make_uint4(tex_img.data_width, tex_img.data_height, offset, options);
+
 		memcpy(pixels_float+offset, (void*)tex_img.data_pointer, tex_img.memory_size());
 		offset += tex_img.size();
 	}
@@ -1178,6 +1236,20 @@ void ImageManager::device_pack_images(Device *device,
 		}
 		device->tex_alloc("__tex_image_float4_packed", dscene->tex_image_float4_packed);
 	}
+	if(dscene->tex_image_byte_packed.size()) {
+		if(dscene->tex_image_byte_packed.device_pointer) {
+			thread_scoped_lock device_lock(device_mutex);
+			device->tex_free(dscene->tex_image_byte_packed);
+		}
+		device->tex_alloc("__tex_image_byte_packed", dscene->tex_image_byte_packed);
+	}
+	if(dscene->tex_image_float_packed.size()) {
+		if(dscene->tex_image_float_packed.device_pointer) {
+			thread_scoped_lock device_lock(device_mutex);
+			device->tex_free(dscene->tex_image_float_packed);
+		}
+		device->tex_alloc("__tex_image_float_packed", dscene->tex_image_float_packed);
+	}
 	if(dscene->tex_image_packed_info.size()) {
 		if(dscene->tex_image_packed_info.device_pointer) {
 			thread_scoped_lock device_lock(device_mutex);
@@ -1208,10 +1280,14 @@ void ImageManager::device_free(Device *device, DeviceScene *dscene)
 
 	device->tex_free(dscene->tex_image_byte4_packed);
 	device->tex_free(dscene->tex_image_float4_packed);
+	device->tex_free(dscene->tex_image_byte_packed);
+	device->tex_free(dscene->tex_image_float_packed);
 	device->tex_free(dscene->tex_image_packed_info);
 
 	dscene->tex_image_byte4_packed.clear();
 	dscene->tex_image_float4_packed.clear();
+	dscene->tex_image_byte_packed.clear();
+	dscene->tex_image_float_packed.clear();
 	dscene->tex_image_packed_info.clear();
 }
 

intern/cycles/render/image.h

@@ -39,9 +39,9 @@ public:
 	enum ImageDataType {
 		IMAGE_DATA_TYPE_FLOAT4 = 0,
 		IMAGE_DATA_TYPE_BYTE4 = 1,
-		IMAGE_DATA_TYPE_FLOAT = 2,
-		IMAGE_DATA_TYPE_BYTE = 3,
-		IMAGE_DATA_TYPE_HALF4 = 4,
+		IMAGE_DATA_TYPE_HALF4 = 2,
+		IMAGE_DATA_TYPE_FLOAT = 3,
+		IMAGE_DATA_TYPE_BYTE = 4,
 		IMAGE_DATA_TYPE_HALF = 5,
 
 		IMAGE_DATA_NUM_TYPES

intern/cycles/render/mesh.cpp

@@ -30,6 +30,7 @@
 
 #include "osl_globals.h"
 
+#include "subd_split.h"
 #include "subd_patch_table.h"
 
 #include "util_foreach.h"
@@ -172,6 +173,7 @@ Mesh::Mesh()
 	num_ngons = 0;
 
 	subdivision_type = SUBDIVISION_NONE;
+	subd_params = NULL;
 
 	patch_table = NULL;
 }
@@ -180,6 +182,7 @@ Mesh::~Mesh()
 {
 	delete bvh;
 	delete patch_table;
+	delete subd_params;
 }
 
 void Mesh::resize_mesh(int numverts, int numtris)
@@ -295,17 +298,17 @@ int Mesh::split_vertex(int vertex)
 
 	foreach(Attribute& attr, attributes.attributes) {
 		if(attr.element == ATTR_ELEMENT_VERTEX) {
-			vector<char> tmp(attr.data_sizeof());
-			memcpy(&tmp[0], attr.data() + tmp.size()*vertex, tmp.size());
-			attr.add(&tmp[0]);
+			array<char> tmp(attr.data_sizeof());
+			memcpy(tmp.data(), attr.data() + tmp.size()*vertex, tmp.size());
+			attr.add(tmp.data());
 		}
 	}
 
 	foreach(Attribute& attr, subd_attributes.attributes) {
 		if(attr.element == ATTR_ELEMENT_VERTEX) {
-			vector<char> tmp(attr.data_sizeof());
-			memcpy(&tmp[0], attr.data() + tmp.size()*vertex, tmp.size());
-			attr.add(&tmp[0]);
+			array<char> tmp(attr.data_sizeof());
+			memcpy(tmp.data(), attr.data() + tmp.size()*vertex, tmp.size());
+			attr.add(tmp.data());
 		}
 	}
 
@@ -471,7 +474,7 @@ void Mesh::add_face_normals()
 	bool flip = transform_negative_scaled;
 
 	if(triangles_size) {
-		float3 *verts_ptr = &verts[0];
+		float3 *verts_ptr = verts.data();
 
 		for(size_t i = 0; i < triangles_size; i++) {
 			fN[i] = compute_face_normal(get_triangle(i), verts_ptr);
@@ -565,7 +568,7 @@ void Mesh::pack_normals(Scene *scene, uint *tri_shader, float4 *vnormal)
 	bool last_smooth = false;
 
 	size_t triangles_size = num_triangles();
-	int *shader_ptr = (shader.size())? &shader[0]: NULL;
+	int *shader_ptr = shader.data();
 
 	bool do_transform = transform_applied;
 	Transform ntfm = transform_normal;
@@ -605,7 +608,7 @@ void Mesh::pack_verts(const vector<uint>& tri_prim_index,
 	size_t verts_size = verts.size();
 
 	if(verts_size && subd_faces.size()) {
-		float2 *vert_patch_uv_ptr = &vert_patch_uv[0];
+		float2 *vert_patch_uv_ptr = vert_patch_uv.data();
 
 		for(size_t i = 0; i < verts_size; i++) {
 			tri_patch_uv[i] = vert_patch_uv_ptr[i];
@@ -633,8 +636,8 @@ void Mesh::pack_curves(Scene *scene, float4 *curve_key_co, float4 *curve_data, s
 
 	/* pack curve keys */
 	if(curve_keys_size) {
-		float3 *keys_ptr = &curve_keys[0];
-		float *radius_ptr = &curve_radius[0];
+		float3 *keys_ptr = curve_keys.data();
+		float *radius_ptr = curve_radius.data();
 
 		for(size_t i = 0; i < curve_keys_size; i++)
 			curve_key_co[i] = make_float4(keys_ptr[i].x, keys_ptr[i].y, keys_ptr[i].z, radius_ptr[i]);
@@ -1659,6 +1662,42 @@ void MeshManager::device_update(Device *device, DeviceScene *dscene, Scene *scen
 		}
 	}
 
+	/* Tessellate meshes that are using subdivision */
+	size_t total_tess_needed = 0;
+	foreach(Mesh *mesh, scene->meshes) {
+		if(mesh->need_update &&
+		   mesh->subdivision_type != Mesh::SUBDIVISION_NONE &&
+		   mesh->num_subd_verts == 0 &&
+		   mesh->subd_params)
+		{
+			total_tess_needed++;
+		}
+	}
+
+	size_t i = 0;
+	foreach(Mesh *mesh, scene->meshes) {
+		if(mesh->need_update &&
+		   mesh->subdivision_type != Mesh::SUBDIVISION_NONE &&
+		   mesh->num_subd_verts == 0 &&
+		   mesh->subd_params)
+		{
+			string msg = "Tessellating ";
+			if(mesh->name == "")
+				msg += string_printf("%u/%u", (uint)(i+1), (uint)total_tess_needed);
+			else
+				msg += string_printf("%s %u/%u", mesh->name.c_str(), (uint)(i+1), (uint)total_tess_needed);
+
+			progress.set_status("Updating Mesh", msg);
+
+			DiagSplit dsplit(*mesh->subd_params);
+			mesh->tessellate(&dsplit);
+
+			i++;
+
+			if(progress.get_cancel()) return;
+		}
+	}
+
 	/* Update images needed for true displacement. */
 	bool true_displacement_used = false;
 	bool old_need_object_flags_update = false;
@@ -1719,7 +1758,7 @@ void MeshManager::device_update(Device *device, DeviceScene *dscene, Scene *scen
 	}
 
 	/* Update bvh. */
-	size_t i = 0, num_bvh = 0;
+	size_t num_bvh = 0;
 	foreach(Mesh *mesh, scene->meshes) {
 		if(mesh->need_update && mesh->need_build_bvh()) {
 			num_bvh++;
@@ -1728,6 +1767,7 @@ void MeshManager::device_update(Device *device, DeviceScene *dscene, Scene *scen
 
 	TaskPool pool;
 
+	i = 0;
 	foreach(Mesh *mesh, scene->meshes) {
 		if(mesh->need_update) {
 			pool.push(function_bind(&Mesh::compute_bvh,

intern/cycles/render/mesh.h

@@ -39,6 +39,7 @@ class Progress;
 class Scene;
 class SceneParams;
 class AttributeRequest;
+struct SubdParams;
 class DiagSplit;
 struct PackedPatchTable;
 
@@ -156,6 +157,8 @@ public:
 
 	array<SubdEdgeCrease> subd_creases;
 
+	SubdParams *subd_params;
+
 	vector<Shader*> used_shaders;
 	AttributeSet attributes;
 	AttributeSet curve_attributes;

intern/cycles/render/mesh_subdivision.cpp

@@ -45,7 +45,7 @@ namespace Far {
 		setNumBaseVertices(refiner, mesh.verts.size());
 		setNumBaseFaces(refiner, mesh.subd_faces.size());
 
-		ccl::Mesh::SubdFace* face = &mesh.subd_faces[0];
+		const ccl::Mesh::SubdFace* face = mesh.subd_faces.data();
 
 		for(int i = 0; i < mesh.subd_faces.size(); i++, face++) {
 			setNumBaseFaceVertices(refiner, i, face->num_corners);
@@ -57,7 +57,7 @@ namespace Far {
 	template<>
 	bool TopologyRefinerFactory<ccl::Mesh>::assignComponentTopology(TopologyRefiner& refiner, ccl::Mesh const& mesh)
 	{
-		ccl::Mesh::SubdFace* face = &mesh.subd_faces[0];
+		const ccl::Mesh::SubdFace* face = mesh.subd_faces.data();
 
 		for(int i = 0; i < mesh.subd_faces.size(); i++, face++) {
 			IndexArray face_verts = getBaseFaceVertices(refiner, i);
@@ -195,7 +195,7 @@ public:
 			verts[i].value = mesh->verts[i];
 		}
 
-		OsdValue<float3>* src = &verts[0];
+		OsdValue<float3>* src = verts.data();
 		for(int i = 0; i < refiner->GetMaxLevel(); i++) {
 			OsdValue<float3>* dest = src + refiner->GetLevel(i).GetNumVertices();
 			Far::PrimvarRefiner(*refiner).Interpolate(i+1, src, dest);
@@ -219,7 +219,7 @@ public:
 			attr.resize(num_refiner_verts + num_local_points);
 			attr.flags |= ATTR_FINAL_SIZE;
 
-			char* src = &attr.buffer[0];
+			char* src = attr.buffer.data();
 
 			for(int i = 0; i < refiner->GetMaxLevel(); i++) {
 				char* dest = src + refiner->GetLevel(i).GetNumVertices() * attr.data_sizeof();

intern/cycles/render/scene.h

@@ -123,6 +123,8 @@ public:
 	/* opencl images */
 	device_vector<uchar4> tex_image_byte4_packed;
 	device_vector<float4> tex_image_float4_packed;
+	device_vector<uchar> tex_image_byte_packed;
+	device_vector<float> tex_image_float_packed;
 	device_vector<uint4> tex_image_packed_info;
 
 	KernelData data;

intern/cycles/render/session.cpp

@@ -635,6 +635,11 @@ DeviceRequestedFeatures Session::get_requested_device_features()
 		}
 		requested_features.use_object_motion |= object->use_motion | mesh->use_motion_blur;
 		requested_features.use_camera_motion |= mesh->use_motion_blur;
+#ifdef WITH_OPENSUBDIV
+		if(mesh->subdivision_type != Mesh::SUBDIVISION_NONE) {
+			requested_features.use_patch_evaluation = true;
+		}
+#endif
 	}
 
 	BakeManager *bake_manager = scene->bake_manager;

intern/cycles/subd/CMakeLists.txt

@@ -22,6 +22,7 @@ set(SRC
 set(SRC_HEADERS
 	subd_dice.h
 	subd_patch.h
+	subd_patch_table.h
 	subd_split.h
 )
 

intern/cycles/subd/subd_dice.cpp

@@ -57,7 +57,7 @@ void EdgeDice::reserve(int num_verts)
 
 	Attribute *attr_vN = mesh->attributes.add(ATTR_STD_VERTEX_NORMAL);
 
-	mesh_P = &mesh->verts[0];
+	mesh_P = mesh->verts.data();
 	mesh_N = attr_vN->data_float3();
 }
 

intern/cycles/subd/subd_patch_table.cpp

@@ -214,7 +214,7 @@ void PackedPatchTable::pack(Far::PatchTable* patch_table, int offset)
 	}
 
 	table.resize(total_size());
-	uint* data = &table[0];
+	uint* data = table.data();
 
 	uint* array = data;
 	uint* index = array + num_arrays * PATCH_ARRAY_SIZE;
@@ -259,7 +259,7 @@ void PackedPatchTable::pack(Far::PatchTable* patch_table, int offset)
 
 void PackedPatchTable::copy_adjusting_offsets(uint* dest, int doffset)
 {
-	uint* src = &table[0];
+	uint* src = table.data();
 
 	/* arrays */
 	for(int i = 0; i < num_arrays; i++) {

intern/cycles/subd/subd_patch_table.h

@@ -43,7 +43,7 @@ namespace Far { struct PatchTable; }
 #define PATCH_NODE_SIZE 1
 
 struct PackedPatchTable {
-	vector<uint> table;
+	array<uint> table;
 
 	size_t num_arrays;
 	size_t num_indices;

intern/cycles/util/CMakeLists.txt

@@ -25,10 +25,6 @@ set(SRC
 	util_windows.cpp
 )
 
-if(NOT CYCLES_STANDALONE_REPOSITORY)
-	add_definitions(-DWITH_GLEW_MX)
-endif()
-
 if(WITH_CYCLES_STANDALONE AND WITH_CYCLES_STANDALONE_GUI)
 	list(APPEND SRC
 		util_view.cpp
@@ -71,6 +67,7 @@ set(SRC_HEADERS
 	util_ssef.h
 	util_ssei.h
 	util_stack_allocator.h
+	util_static_assert.h
 	util_stats.h
 	util_string.h
 	util_system.h

intern/cycles/util/util_debug.h

@@ -20,6 +20,8 @@
 #include <cassert>
 #include <iostream>
 
+#include "util_static_assert.h"
+
 CCL_NAMESPACE_BEGIN
 
 /* Global storage for all sort of flags used to fine-tune behavior of particular

intern/cycles/util/util_half.h

@@ -33,17 +33,21 @@ CCL_NAMESPACE_BEGIN
 
 #else
 
+/* CUDA has its own half data type, no need to define then */
+#ifndef __KERNEL_CUDA__
 typedef unsigned short half;
+#endif
+
 struct half4 { half x, y, z, w; };
 
 #ifdef __KERNEL_CUDA__
 
 ccl_device_inline void float4_store_half(half *h, float4 f, float scale)
 {
-	h[0] = __float2half_rn(f.x * scale);
-	h[1] = __float2half_rn(f.y * scale);
-	h[2] = __float2half_rn(f.z * scale);
-	h[3] = __float2half_rn(f.w * scale);
+	h[0] = __float2half(f.x * scale);
+	h[1] = __float2half(f.y * scale);
+	h[2] = __float2half(f.z * scale);
+	h[3] = __float2half(f.w * scale);
 }
 
 #else

intern/cycles/util/util_static_assert.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2011-2016 Blender Foundation
+ *
+ * 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.
+ */
+
+#ifndef __UTIL_STATIC_ASSERT_H__
+#define __UTIL_STATIC_ASSERT_H__
+
+CCL_NAMESPACE_BEGIN
+
+/* TODO(sergey): In theory CUDA might work with own static assert
+ * implementation since it's just pure C++.
+ */
+#ifndef __KERNEL_GPU__
+#  if (__cplusplus > 199711L) || (defined(_MSC_VER) && _MSC_VER >= 1800)
+/* C++11 has built-in static_assert() */
+#  else  /* C++11 or MSVC2015 */
+template <bool Test> class StaticAssertFailure;
+template <> class StaticAssertFailure<true> {};
+#    define _static_assert_private_glue_impl(A, B) A ## B
+#    define _static_assert_glue(A, B) _static_assert_private_glue_impl(A, B)
+#    ifdef __COUNTER__
+#      define static_assert(condition, message) \
+  enum {_static_assert_glue(q_static_assert_result, __COUNTER__) = sizeof(StaticAssertFailure<!!(condition)>)}  // NOLINT
+#    else  /* __COUNTER__ */
+#      define static_assert(condition, message) \
+  enum {_static_assert_glue(q_static_assert_result, __LINE__) = sizeof(StaticAssertFailure<!!(condition)>)}  // NOLINT
+#    endif  /* __COUNTER__ */
+#  endif  /* C++11 or MSVC2015 */
+#else  /* __KERNEL_GPU__ */
+#  define static_assert(statement, message)
+#endif  /* __KERNEL_GPU__ */
+
+/* TODO(sergey): For until C++11 is a bare minimum for us,
+ * we do a bit of a trickery to show meaningful message so
+ * it's more or less clear what's wrong when building without
+ * C++11.
+ *
+ * The thing here is: our non-C++11 implementation doesn't
+ * have a way to print any message after preprocessor
+ * substitution so we rely on the message which is passed to
+ * static_assert() since that's the only message visible when
+ * compilation fails.
+ *
+ * After C++11 bump it should be possible to glue structure
+ * name to the error message,
+ */
+#  define static_assert_align(st, align) \
+  static_assert((sizeof(st) % (align) == 0), "Structure must be strictly aligned")  // NOLINT
+
+CCL_NAMESPACE_END
+
+#endif /* __UTIL_STATIC_ASSERT_H__ */

intern/cycles/util/util_texture.h

@@ -24,58 +24,58 @@ CCL_NAMESPACE_BEGIN
 /* CPU */
 #define TEX_NUM_FLOAT4_CPU		1024
 #define TEX_NUM_BYTE4_CPU		1024
+#define TEX_NUM_HALF4_CPU		1024
 #define TEX_NUM_FLOAT_CPU		1024
 #define TEX_NUM_BYTE_CPU		1024
-#define TEX_NUM_HALF4_CPU		1024
 #define TEX_NUM_HALF_CPU		1024
 #define TEX_START_FLOAT4_CPU	0
 #define TEX_START_BYTE4_CPU		TEX_NUM_FLOAT4_CPU
-#define TEX_START_FLOAT_CPU		(TEX_NUM_FLOAT4_CPU + TEX_NUM_BYTE4_CPU)
-#define TEX_START_BYTE_CPU		(TEX_NUM_FLOAT4_CPU + TEX_NUM_BYTE4_CPU + TEX_NUM_FLOAT_CPU)
-#define TEX_START_HALF4_CPU		(TEX_NUM_FLOAT4_CPU + TEX_NUM_BYTE4_CPU + TEX_NUM_FLOAT_CPU + TEX_NUM_BYTE_CPU)
-#define TEX_START_HALF_CPU		(TEX_NUM_FLOAT4_CPU + TEX_NUM_BYTE4_CPU + TEX_NUM_FLOAT_CPU + TEX_NUM_BYTE_CPU + TEX_NUM_HALF4_CPU)
+#define TEX_START_HALF4_CPU		(TEX_NUM_FLOAT4_CPU + TEX_NUM_BYTE4_CPU)
+#define TEX_START_FLOAT_CPU		(TEX_NUM_FLOAT4_CPU + TEX_NUM_BYTE4_CPU + TEX_NUM_HALF4_CPU)
+#define TEX_START_BYTE_CPU		(TEX_NUM_FLOAT4_CPU + TEX_NUM_BYTE4_CPU + TEX_NUM_HALF4_CPU + TEX_NUM_FLOAT_CPU)
+#define TEX_START_HALF_CPU		(TEX_NUM_FLOAT4_CPU + TEX_NUM_BYTE4_CPU + TEX_NUM_HALF4_CPU + TEX_NUM_FLOAT_CPU + TEX_NUM_BYTE_CPU)
 
 /* CUDA (Geforce 4xx and 5xx) */
 #define TEX_NUM_FLOAT4_CUDA		5
-#define TEX_NUM_BYTE4_CUDA		88
+#define TEX_NUM_BYTE4_CUDA		85
+#define TEX_NUM_HALF4_CUDA		0
 #define TEX_NUM_FLOAT_CUDA		0
 #define TEX_NUM_BYTE_CUDA		0
-#define TEX_NUM_HALF4_CUDA		0
 #define TEX_NUM_HALF_CUDA		0
 #define TEX_START_FLOAT4_CUDA	0
 #define TEX_START_BYTE4_CUDA	TEX_NUM_FLOAT4_CUDA
-#define TEX_START_FLOAT_CUDA	(TEX_NUM_FLOAT4_CUDA + TEX_NUM_BYTE4_CUDA)
-#define TEX_START_BYTE_CUDA		(TEX_NUM_FLOAT4_CUDA + TEX_NUM_BYTE4_CUDA + TEX_NUM_FLOAT_CUDA)
-#define TEX_START_HALF4_CUDA	(TEX_NUM_FLOAT4_CUDA + TEX_NUM_BYTE4_CUDA + TEX_NUM_FLOAT_CUDA + TEX_NUM_BYTE_CUDA)
-#define TEX_START_HALF_CUDA		(TEX_NUM_FLOAT4_CUDA + TEX_NUM_BYTE4_CUDA + TEX_NUM_FLOAT_CUDA + TEX_NUM_BYTE_CUDA + TEX_NUM_HALF4_CUDA)
+#define TEX_START_HALF4_CUDA	(TEX_NUM_FLOAT4_CUDA + TEX_NUM_BYTE4_CUDA)
+#define TEX_START_FLOAT_CUDA	(TEX_NUM_FLOAT4_CUDA + TEX_NUM_BYTE4_CUDA + TEX_NUM_HALF4_CUDA)
+#define TEX_START_BYTE_CUDA		(TEX_NUM_FLOAT4_CUDA + TEX_NUM_BYTE4_CUDA + TEX_NUM_HALF4_CUDA + TEX_NUM_FLOAT_CUDA)
+#define TEX_START_HALF_CUDA		(TEX_NUM_FLOAT4_CUDA + TEX_NUM_BYTE4_CUDA + TEX_NUM_HALF4_CUDA + TEX_NUM_FLOAT_CUDA + TEX_NUM_BYTE_CUDA)
 
 /* CUDA (Kepler, Geforce 6xx and above) */
 #define TEX_NUM_FLOAT4_CUDA_KEPLER		1024
 #define TEX_NUM_BYTE4_CUDA_KEPLER		1024
+#define TEX_NUM_HALF4_CUDA_KEPLER		1024
 #define TEX_NUM_FLOAT_CUDA_KEPLER		1024
 #define TEX_NUM_BYTE_CUDA_KEPLER		1024
-#define TEX_NUM_HALF4_CUDA_KEPLER		0
-#define TEX_NUM_HALF_CUDA_KEPLER		0
+#define TEX_NUM_HALF_CUDA_KEPLER		1024
 #define TEX_START_FLOAT4_CUDA_KEPLER	0
 #define TEX_START_BYTE4_CUDA_KEPLER		TEX_NUM_FLOAT4_CUDA_KEPLER
-#define TEX_START_FLOAT_CUDA_KEPLER		(TEX_NUM_FLOAT4_CUDA_KEPLER + TEX_NUM_BYTE4_CUDA_KEPLER)
-#define TEX_START_BYTE_CUDA_KEPLER		(TEX_NUM_FLOAT4_CUDA_KEPLER + TEX_NUM_BYTE4_CUDA_KEPLER + TEX_NUM_FLOAT_CUDA_KEPLER)
-#define TEX_START_HALF4_CUDA_KEPLER		(TEX_NUM_FLOAT4_CUDA_KEPLER + TEX_NUM_BYTE4_CUDA_KEPLER + TEX_NUM_FLOAT_CUDA_KEPLER + TEX_NUM_BYTE_CUDA_KEPLER)
-#define TEX_START_HALF_CUDA_KEPLER		(TEX_NUM_FLOAT4_CUDA_KEPLER + TEX_NUM_BYTE4_CUDA_KEPLER + TEX_NUM_FLOAT_CUDA_KEPLER + TEX_NUM_BYTE_CUDA_KEPLER + TEX_NUM_HALF4_CUDA_KEPLER)
+#define TEX_START_HALF4_CUDA_KEPLER		(TEX_NUM_FLOAT4_CUDA_KEPLER + TEX_NUM_BYTE4_CUDA_KEPLER)
+#define TEX_START_FLOAT_CUDA_KEPLER		(TEX_NUM_FLOAT4_CUDA_KEPLER + TEX_NUM_BYTE4_CUDA_KEPLER + TEX_NUM_HALF4_CUDA_KEPLER)
+#define TEX_START_BYTE_CUDA_KEPLER		(TEX_NUM_FLOAT4_CUDA_KEPLER + TEX_NUM_BYTE4_CUDA_KEPLER + TEX_NUM_HALF4_CUDA_KEPLER + TEX_NUM_FLOAT_CUDA_KEPLER)
+#define TEX_START_HALF_CUDA_KEPLER		(TEX_NUM_FLOAT4_CUDA_KEPLER + TEX_NUM_BYTE4_CUDA_KEPLER + TEX_NUM_HALF4_CUDA_KEPLER + TEX_NUM_FLOAT_CUDA_KEPLER + TEX_NUM_BYTE_CUDA_KEPLER)
 
 /* OpenCL */
 #define TEX_NUM_FLOAT4_OPENCL	1024
 #define TEX_NUM_BYTE4_OPENCL	1024
-#define TEX_NUM_FLOAT_OPENCL	0
-#define TEX_NUM_BYTE_OPENCL		0
 #define TEX_NUM_HALF4_OPENCL	0
+#define TEX_NUM_FLOAT_OPENCL	1024
+#define TEX_NUM_BYTE_OPENCL		1024
 #define TEX_NUM_HALF_OPENCL		0
 #define TEX_START_FLOAT4_OPENCL	0
 #define TEX_START_BYTE4_OPENCL	TEX_NUM_FLOAT4_OPENCL
-#define TEX_START_FLOAT_OPENCL	(TEX_NUM_FLOAT4_OPENCL + TEX_NUM_BYTE4_OPENCL)
-#define TEX_START_BYTE_OPENCL	(TEX_NUM_FLOAT4_OPENCL + TEX_NUM_BYTE4_OPENCL + TEX_NUM_FLOAT_OPENCL)
-#define TEX_START_HALF4_OPENCL	(TEX_NUM_FLOAT4_OPENCL + TEX_NUM_BYTE4_OPENCL + TEX_NUM_FLOAT_OPENCL + TEX_NUM_BYTE_OPENCL)
-#define TEX_START_HALF_OPENCL	(TEX_NUM_FLOAT4_OPENCL + TEX_NUM_BYTE4_OPENCL + TEX_NUM_FLOAT_OPENCL + TEX_NUM_BYTE_OPENCL + TEX_NUM_HALF4_OPENCL)
+#define TEX_START_HALF4_OPENCL	(TEX_NUM_FLOAT4_OPENCL + TEX_NUM_BYTE4_OPENCL)
+#define TEX_START_FLOAT_OPENCL	(TEX_NUM_FLOAT4_OPENCL + TEX_NUM_BYTE4_OPENCL + TEX_NUM_HALF4_OPENCL)
+#define TEX_START_BYTE_OPENCL	(TEX_NUM_FLOAT4_OPENCL + TEX_NUM_BYTE4_OPENCL + TEX_NUM_HALF4_OPENCL + TEX_NUM_FLOAT_OPENCL)
+#define TEX_START_HALF_OPENCL	(TEX_NUM_FLOAT4_OPENCL + TEX_NUM_BYTE4_OPENCL + TEX_NUM_HALF4_OPENCL + TEX_NUM_FLOAT_OPENCL + TEX_NUM_BYTE_OPENCL)
 
 
 /* Color to use when textures are not found. */

intern/ghost/GHOST_C-api.h

@@ -433,6 +433,7 @@ extern GHOST_TSuccess GHOST_GetButtonState(GHOST_SystemHandle systemhandle,
                                            GHOST_TButtonMask mask,
                                            int *isDown);
 
+#ifdef WITH_INPUT_NDOF
 /***************************************************************************************
  * Access to 3D mouse.
  ***************************************************************************************/
@@ -442,6 +443,7 @@ extern GHOST_TSuccess GHOST_GetButtonState(GHOST_SystemHandle systemhandle,
  * \param deadzone Deadzone of the 3D mouse (both for rotation and pan) relative to full range
  */
 extern void GHOST_setNDOFDeadZone(float deadzone);
+#endif
 
 
 /***************************************************************************************

intern/ghost/GHOST_ISystem.h

@@ -377,11 +377,13 @@ public:
 	 */
 	virtual GHOST_TSuccess getButtonState(GHOST_TButtonMask mask, bool& isDown) const = 0;
 
+#ifdef WITH_INPUT_NDOF
 	/**
 	 * Sets 3D mouse deadzone
 	 * \param deadzone: Deadzone of the 3D mouse (both for rotation and pan) relative to full range
 	 */
 	virtual void setNDOFDeadZone(float deadzone) = 0;
+#endif
 
 	/**
 	 * Toggles console

intern/ghost/GHOST_Types.h

@@ -172,8 +172,10 @@ typedef enum {
 	GHOST_kEventWheel,          /// Mouse wheel event
 	GHOST_kEventTrackpad,       /// Trackpad event
 
+#ifdef WITH_INPUT_NDOF
 	GHOST_kEventNDOFMotion,     /// N degree of freedom device motion event
 	GHOST_kEventNDOFButton,     /// N degree of freedom device button event
+#endif
 
 	GHOST_kEventKeyDown,
 	GHOST_kEventKeyUp,
@@ -478,6 +480,7 @@ typedef enum {
 	GHOST_kFinished
 } GHOST_TProgress;
 
+#ifdef WITH_INPUT_NDOF
 typedef struct {
 	/** N-degree of freedom device data v3 [GSoC 2010] */
 	// Each component normally ranges from -1 to +1, but can exceed that.
@@ -497,6 +500,7 @@ typedef struct {
 	GHOST_TButtonAction action;
 	short button;
 } GHOST_TEventNDOFButtonData;
+#endif // WITH_INPUT_NDOF
 
 typedef struct {
 	/** The key code. */

intern/ghost/intern/GHOST_C-api.cpp

@@ -406,12 +406,13 @@ GHOST_TSuccess GHOST_GetButtonState(GHOST_SystemHandle systemhandle,
 }
 
 
+#ifdef WITH_INPUT_NDOF
 void GHOST_setNDOFDeadZone(float deadzone)
 {
 	GHOST_ISystem *system = GHOST_ISystem::getSystem();
 	system->setNDOFDeadZone(deadzone);
 }
-
+#endif
 
 void GHOST_setAcceptDragOperation(GHOST_WindowHandle windowhandle, GHOST_TInt8 canAccept)
 {

intern/ghost/intern/GHOST_EventNDOF.h

@@ -22,9 +22,12 @@
 
 /** \file ghost/intern/GHOST_EventNDOF.h
  *  \ingroup GHOST
- * Declaration of GHOST_EventManager class.
  */
 
+#ifndef WITH_INPUT_NDOF
+#  error NDOF code included in non-NDOF-enabled build
+#endif
+
 #ifndef __GHOST_EVENTNDOF_H__
 #define __GHOST_EVENTNDOF_H__
 

intern/ghost/intern/GHOST_NDOFManager.h

@@ -21,6 +21,10 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
+#ifndef WITH_INPUT_NDOF
+#  error NDOF code included in non-NDOF-enabled build
+#endif
+
 #ifndef __GHOST_NDOFMANAGER_H__
 #define __GHOST_NDOFMANAGER_H__
 

intern/ghost/intern/GHOST_NDOFManagerCocoa.h

@@ -24,8 +24,6 @@
 #ifndef __GHOST_NDOFMANAGERCOCOA_H__
 #define __GHOST_NDOFMANAGERCOCOA_H__
 
-#ifdef WITH_INPUT_NDOF
-
 #include "GHOST_NDOFManager.h"
 
 // Event capture is handled within the NDOF manager on Macintosh,
@@ -40,6 +38,4 @@ public:
 	bool available();
 };
 
-
-#endif // WITH_INPUT_NDOF
 #endif // #include guard

intern/ghost/intern/GHOST_NDOFManagerCocoa.mm

@@ -210,7 +210,9 @@ static void DeviceEvent(uint32_t unused, uint32_t msg_type, void* msg_arg)
 				case kConnexionCmdHandleButtons:
 				{
 					int button_bits = has_old_driver ? s->buttons8 : s->buttons;
+#ifdef DEBUG_NDOF_BUTTONS
 					printf("button bits: 0x%08x\n", button_bits);
+#endif
 					ndof_manager->updateButtons(button_bits, now);
 					ghost_system->notifyExternalEventProcessed();
 					break;

intern/ghost/intern/GHOST_NDOFManagerUnix.cpp

@@ -21,8 +21,6 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
-#ifdef WITH_INPUT_NDOF
-
 #include "GHOST_NDOFManagerUnix.h"
 #include "GHOST_System.h"
 
@@ -144,5 +142,3 @@ bool GHOST_NDOFManagerUnix::processEvents()
 
 	return anyProcessed;
 }
-
-#endif /* WITH_INPUT_NDOF */

intern/ghost/intern/GHOST_NDOFManagerUnix.h

@@ -24,8 +24,6 @@
 #ifndef __GHOST_NDOFMANAGERUNIX_H__
 #define __GHOST_NDOFMANAGERUNIX_H__
 
-#ifdef WITH_INPUT_NDOF
-
 #include "GHOST_NDOFManager.h"
 
 /* Event capture is handled within the NDOF manager on Linux,
@@ -43,5 +41,4 @@ private:
 	bool m_available;
 };
 
-#endif  /* WITH_INPUT_NDOF */
 #endif  /* __GHOST_NDOFMANAGERUNIX_H__ */

intern/ghost/intern/GHOST_NDOFManagerWin32.cpp

@@ -22,8 +22,6 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
-#ifdef WITH_INPUT_NDOF // use contents of this file
-
 #include "GHOST_NDOFManagerWin32.h"
 
 
@@ -40,5 +38,3 @@ bool GHOST_NDOFManagerWin32::available()
 	// always available since RawInput is built into Windows
 	return true;
 }
-
-#endif // WITH_INPUT_NDOF

intern/ghost/intern/GHOST_NDOFManagerWin32.h

@@ -25,8 +25,6 @@
 #ifndef __GHOST_NDOFMANAGERWIN32_H__
 #define __GHOST_NDOFMANAGERWIN32_H__
 
-#ifdef WITH_INPUT_NDOF
-
 #include "GHOST_NDOFManager.h"
 
 
@@ -37,6 +35,4 @@ public:
 	bool available();
 };
 
-
-#endif // WITH_INPUT_NDOF
 #endif // #include guard

intern/ghost/intern/GHOST_System.cpp

@@ -38,11 +38,13 @@
 
 #include "GHOST_DisplayManager.h"
 #include "GHOST_EventManager.h"
-#include "GHOST_NDOFManager.h"
 #include "GHOST_TimerTask.h"
 #include "GHOST_TimerManager.h"
 #include "GHOST_WindowManager.h"
 
+#ifdef WITH_INPUT_NDOF
+#  include "GHOST_NDOFManager.h"
+#endif
 
 GHOST_System::GHOST_System()
     : m_nativePixel(false),
@@ -292,14 +294,12 @@ GHOST_TSuccess GHOST_System::getButtonState(GHOST_TButtonMask mask, bool& isDown
 	return success;
 }
 
+#ifdef WITH_INPUT_NDOF
 void GHOST_System::setNDOFDeadZone(float deadzone)
 {
-#ifdef WITH_INPUT_NDOF
 	this->m_ndofManager->setDeadZone(deadzone);
-#else
-	(void)deadzone;
-#endif
 }
+#endif
 
 GHOST_TSuccess GHOST_System::init()
 {
@@ -345,6 +345,7 @@ GHOST_TSuccess GHOST_System::exit()
 	delete m_ndofManager;
 	m_ndofManager = NULL;
 #endif
+
 	return GHOST_kSuccess;
 }
 

intern/ghost/intern/GHOST_System.h

@@ -48,7 +48,9 @@ class GHOST_Event;
 class GHOST_TimerManager;
 class GHOST_Window;
 class GHOST_WindowManager;
+#ifdef WITH_INPUT_NDOF
 class GHOST_NDOFManager;
+#endif
 
 /**
  * Implementation of platform independent functionality of the GHOST_ISystem
@@ -236,6 +238,7 @@ public:
 	 */
 	GHOST_TSuccess getButtonState(GHOST_TButtonMask mask, bool& isDown) const;
 	
+#ifdef WITH_INPUT_NDOF
 	/***************************************************************************************
 	 * Access to 3D mouse.
 	 ***************************************************************************************/
@@ -245,6 +248,7 @@ public:
 	 * \param deadzone: Deadzone of the 3D mouse (both for rotation and pan) relative to full range
 	 */
 	void setNDOFDeadZone(float deadzone);
+#endif
 
 	/***************************************************************************************
 	 * Other (internal) functionality.

intern/ghost/intern/GHOST_SystemWin32.cpp

@@ -57,7 +57,7 @@
 #include "GHOST_WindowWin32.h"
 
 #ifdef WITH_INPUT_NDOF
-#include "GHOST_NDOFManagerWin32.h"
+  #include "GHOST_NDOFManagerWin32.h"
 #endif
 
 // Key code values not found in winuser.h
@@ -125,9 +125,9 @@
 static void initRawInput()
 {
 #ifdef WITH_INPUT_NDOF
-#define DEVICE_COUNT 2
+  #define DEVICE_COUNT 2
 #else
-#define DEVICE_COUNT 1
+  #define DEVICE_COUNT 1
 #endif
 
 	RAWINPUTDEVICE devices[DEVICE_COUNT];

intern/opensubdiv/opensubdiv_gpu_capi.cc

@@ -115,7 +115,7 @@ static Transform g_transform;
 struct OpenSubdiv_GLMeshFVarData
 {
 	OpenSubdiv_GLMeshFVarData() :
-		texture_buffer(0) {
+		texture_buffer(0), offset_buffer(0) {
 	}
 
 	~OpenSubdiv_GLMeshFVarData()

release/scripts/modules/bl_i18n_utils/utils_spell_check.py

@@ -197,6 +197,7 @@ class SpellChecker:
         "unmute",
         "unpremultiply",
         "unprojected",
+        "unprotect",
         "unreacted",
         "unregister",
         "unselected", "unselectable",
@@ -493,6 +494,7 @@ class SpellChecker:
         "musgrave",
         "nayar",
         "netravali",
+        "ogawa",
         "oren",
         "preetham",
         "prewitt",

release/scripts/modules/bl_previews_utils/bl_previews_render.py

@@ -169,7 +169,7 @@ def do_previews(do_objects, do_groups, do_scenes, do_data_intern):
                     scene.objects.unlink(bpy.data.objects[render_context.camera, None])
                 if render_context.lamp:
                     scene.objects.unlink(bpy.data.objects[render_context.lamp, None])
-                bpy.data.scenes.remove(scene)
+                bpy.data.scenes.remove(scene, do_unlink=True)
                 scene = None
             else:
                 rna_backup_restore(scene, render_context.backup_scene)

release/scripts/startup/bl_operators/object_align.py

@@ -365,6 +365,7 @@ class AlignObjects(Operator):
             )
     align_mode = EnumProperty(
             name="Align Mode:",
+            description="Side of object to use for alignment",
             items=(('OPT_1', "Negative Sides", ""),
                    ('OPT_2', "Centers", ""),
                    ('OPT_3', "Positive Sides", ""),
@@ -373,10 +374,11 @@ class AlignObjects(Operator):
             )
     relative_to = EnumProperty(
             name="Relative To:",
-            items=(('OPT_1', "Scene Origin", ""),
-                   ('OPT_2', "3D Cursor", ""),
-                   ('OPT_3', "Selection", ""),
-                   ('OPT_4', "Active", ""),
+            description="Reference location to align to",
+            items=(('OPT_1', "Scene Origin", "Use the Scene Origin as the position for the selected objects to align to"),
+                   ('OPT_2', "3D Cursor", "Use the 3D cursor as the position for the selected objects to align to"),
+                   ('OPT_3', "Selection", "Use the selected objects as the position for the selected objects to align to"),
+                   ('OPT_4', "Active", "Use the active object as the position for the selected objects to align to"),
                    ),
             default='OPT_4',
             )

release/scripts/startup/bl_ui/space_clip.py

@@ -621,6 +621,7 @@ class CLIP_PT_track(CLIP_PT_tracking_panel, Panel):
                  text="", toggle=True, icon='IMAGE_ALPHA')
 
         layout.prop(act_track, "weight")
+        layout.prop(act_track, "weight_stab")
 
         if act_track.has_bundle:
             label_text = "Average Error: %.4f" % (act_track.average_error)
@@ -907,44 +908,80 @@ class CLIP_PT_stabilization(CLIP_PT_reconstruction_panel, Panel):
         self.layout.prop(stab, "use_2d_stabilization", text="")
 
     def draw(self, context):
-        layout = self.layout
-
         tracking = context.space_data.clip.tracking
         stab = tracking.stabilization
 
+        layout = self.layout
         layout.active = stab.use_2d_stabilization
 
+        layout.prop(stab, "anchor_frame")
+
+        row = layout.row(align=True)
+        row.prop(stab, "use_stabilize_rotation", text="Rotation", toggle=True)
+        sub = row.row(align=True)
+        sub.active = stab.use_stabilize_rotation
+        sub.prop(stab, "use_stabilize_scale", text="Scale", toggle=True)
+
+        box = layout.box()
+        row = box.row(align=True)
+        row.prop(stab, "show_tracks_expanded", text="", emboss=False)
+
+        if not stab.show_tracks_expanded:
+            row.label(text="Tracks For Stabilization")
+        else:
+            row.label(text="Tracks For Location")
+            row = box.row()
+            row.template_list("UI_UL_list", "stabilization_tracks", stab, "tracks",
+                              stab, "active_track_index", rows=2)
+
+            sub = row.column(align=True)
+
+            sub.operator("clip.stabilize_2d_add", icon='ZOOMIN', text="")
+            sub.operator("clip.stabilize_2d_remove", icon='ZOOMOUT', text="")
+
+            sub.menu('CLIP_MT_stabilize_2d_specials', text="",
+                     icon='DOWNARROW_HLT')
+
+            # Usually we don't hide things from iterface, but here every pixel of
+            # vertical space is precious.
+            if stab.use_stabilize_rotation:
+                box.label(text="Tracks For Rotation / Scale")
+                row = box.row()
+                row.template_list("UI_UL_list", "stabilization_rotation_tracks",
+                                  stab, "rotation_tracks",
+                                  stab, "active_rotation_track_index", rows=2)
+
+                sub = row.column(align=True)
+
+                sub.operator("clip.stabilize_2d_rotation_add", icon='ZOOMIN', text="")
+                sub.operator("clip.stabilize_2d_rotation_remove", icon='ZOOMOUT', text="")
+
+                sub.menu('CLIP_MT_stabilize_2d_rotation_specials', text="",
+                         icon='DOWNARROW_HLT')
+
         row = layout.row()
-        row.template_list("UI_UL_list", "stabilization_tracks", stab, "tracks",
-                          stab, "active_track_index", rows=2)
-
-        sub = row.column(align=True)
-
-        sub.operator("clip.stabilize_2d_add", icon='ZOOMIN', text="")
-        sub.operator("clip.stabilize_2d_remove", icon='ZOOMOUT', text="")
-
-        sub.menu('CLIP_MT_stabilize_2d_specials', text="",
-                 icon='DOWNARROW_HLT')
-
-        layout.prop(stab, "influence_location")
-
-        layout.prop(stab, "use_autoscale")
-        col = layout.column()
-        col.active = stab.use_autoscale
-        col.prop(stab, "scale_max")
-        col.prop(stab, "influence_scale")
-
-        layout.prop(stab, "use_stabilize_rotation")
-        col = layout.column()
-        col.active = stab.use_stabilize_rotation
+        row.active = stab.use_stabilize_rotation
+        row.prop(stab, "use_autoscale")
+        sub = row.row()
+        sub.active = stab.use_autoscale
+        sub.prop(stab, "scale_max", text="Max")
 
+        col = layout.column(align=True)
         row = col.row(align=True)
-        row.prop_search(stab, "rotation_track", tracking, "tracks", text="")
-        row.operator("clip.stabilize_2d_set_rotation", text="", icon='ZOOMIN')
+        # Hrm, how to make it more obvious label?
+        row.prop(stab, "target_position", text="")
+        col.prop(stab, "target_rotation")
+        if stab.use_autoscale:
+            col.label(text="Auto Scale Factor: %5.3f" % (1.0 / stab.target_zoom))
+        else:
+            col.prop(stab, "target_zoom")
 
-        row = col.row()
-        row.active = stab.rotation_track is not None
-        row.prop(stab, "influence_rotation")
+        col = layout.column(align=True)
+        col.prop(stab, "influence_location")
+        sub = col.column(align=True)
+        sub.active = stab.use_stabilize_rotation
+        sub.prop(stab, "influence_rotation")
+        sub.prop(stab, "influence_scale")
 
         layout.prop(stab, "filter_type")
 
@@ -1434,7 +1471,7 @@ class CLIP_MT_track_color_specials(Menu):
 
 
 class CLIP_MT_stabilize_2d_specials(Menu):
-    bl_label = "Track Color Specials"
+    bl_label = "Translation Track Specials"
 
     def draw(self, context):
         layout = self.layout
@@ -1442,5 +1479,14 @@ class CLIP_MT_stabilize_2d_specials(Menu):
         layout.operator("clip.stabilize_2d_select")
 
 
+class CLIP_MT_stabilize_2d_rotation_specials(Menu):
+    bl_label = "Rotation Track Specials"
+
+    def draw(self, context):
+        layout = self.layout
+
+        layout.operator("clip.stabilize_2d_rotation_select")
+
+
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)

release/scripts/startup/bl_ui/space_userpref.py

@@ -1176,15 +1176,16 @@ class USERPREF_PT_input(Panel):
             sub.prop(walk, "view_height")
             sub.prop(walk, "jump_height")
 
-        col.separator()
-        col.label(text="NDOF Device:")
-        sub = col.column(align=True)
-        sub.prop(inputs, "ndof_sensitivity", text="NDOF Sensitivity")
-        sub.prop(inputs, "ndof_orbit_sensitivity", text="NDOF Orbit Sensitivity")
-        sub.prop(inputs, "ndof_deadzone", text="NDOF Deadzone")
-        sub = col.column(align=True)
-        sub.row().prop(inputs, "ndof_view_navigate_method", expand=True)
-        sub.row().prop(inputs, "ndof_view_rotate_method", expand=True)
+        if inputs.use_ndof:
+            col.separator()
+            col.label(text="NDOF Device:")
+            sub = col.column(align=True)
+            sub.prop(inputs, "ndof_sensitivity", text="NDOF Sensitivity")
+            sub.prop(inputs, "ndof_orbit_sensitivity", text="NDOF Orbit Sensitivity")
+            sub.prop(inputs, "ndof_deadzone", text="NDOF Deadzone")
+            sub = col.column(align=True)
+            sub.row().prop(inputs, "ndof_view_navigate_method", expand=True)
+            sub.row().prop(inputs, "ndof_view_rotate_method", expand=True)
 
         row.separator()
 

source/blender/alembic/intern/abc_camera.cc

@@ -109,7 +109,7 @@ AbcCameraReader::AbcCameraReader(const Alembic::Abc::IObject &object, ImportSett
 	ICamera abc_cam(m_iobject, kWrapExisting);
 	m_schema = abc_cam.getSchema();
 
-	get_min_max_time(m_schema, m_min_time, m_max_time);
+	get_min_max_time(m_iobject, m_schema, m_min_time, m_max_time);
 }
 
 bool AbcCameraReader::valid() const

source/blender/alembic/intern/abc_curves.cc

@@ -190,7 +190,7 @@ AbcCurveReader::AbcCurveReader(const Alembic::Abc::IObject &object, ImportSettin
 	ICurves abc_curves(object, kWrapExisting);
 	m_curves_schema = abc_curves.getSchema();
 
-	get_min_max_time(m_curves_schema, m_min_time, m_max_time);
+	get_min_max_time(m_iobject, m_curves_schema, m_min_time, m_max_time);
 }
 
 bool AbcCurveReader::valid() const

source/blender/alembic/intern/abc_exporter.cc

@@ -44,6 +44,7 @@ extern "C" {
 #include "DNA_curve_types.h"
 #include "DNA_mesh_types.h"
 #include "DNA_modifier_types.h"
+#include "DNA_object_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_space_types.h"  /* for FILE_MAX */
 
@@ -59,7 +60,6 @@ extern "C" {
 #include "BKE_idprop.h"
 #include "BKE_main.h"
 #include "BKE_modifier.h"
-#include "BKE_particle.h"
 #include "BKE_scene.h"
 }
 
@@ -175,7 +175,7 @@ void AbcExporter::getShutterSamples(double step, bool time_relative,
 	/* sample all frame */
 	if (shutter_open == 0.0 && shutter_close == 1.0) {
 		for (double t = 0; t < 1.0; t += step) {
-			samples.push_back(t / time_factor);
+			samples.push_back((t + m_settings.frame_start) / time_factor);
 		}
 	}
 	else {
@@ -184,7 +184,7 @@ void AbcExporter::getShutterSamples(double step, bool time_relative,
 		const double time_inc = (shutter_close - shutter_open) / nsamples;
 
 		for (double t = shutter_open; t <= shutter_close; t += time_inc) {
-			samples.push_back(t / time_factor);
+			samples.push_back((t + m_settings.frame_start) / time_factor);
 		}
 	}
 }
@@ -325,16 +325,18 @@ void AbcExporter::operator()(Main *bmain, float &progress, bool &was_canceled)
 			break;
 		}
 
-		double f = *begin;
-		setCurrentFrame(bmain, f);
+		const double frame = *begin;
 
-		if (shape_frames.count(f) != 0) {
+		/* 'frame' is offset by start frame, so need to cancel the offset. */
+		setCurrentFrame(bmain, frame - m_settings.frame_start);
+
+		if (shape_frames.count(frame) != 0) {
 			for (int i = 0, e = m_shapes.size(); i != e; ++i) {
 				m_shapes[i]->write();
 			}
 		}
 
-		if (xform_frames.count(f) == 0) {
+		if (xform_frames.count(frame) == 0) {
 			continue;
 		}
 
@@ -518,22 +520,6 @@ void AbcExporter::createShapeWriter(Object *ob, Object *dupliObParent)
 		return;
 	}
 
-	ParticleSystem *psys = static_cast<ParticleSystem *>(ob->particlesystem.first);
-
-	for (; psys; psys = psys->next) {
-		if (!psys_check_enabled(ob, psys, G.is_rendering) || !psys->part) {
-			continue;
-		}
-
-		if (psys->part->type == PART_HAIR) {
-			m_settings.export_child_hairs = true;
-			m_shapes.push_back(new AbcHairWriter(m_scene, ob, xform, m_shape_sampling_index, m_settings, psys));
-		}
-		else if (psys->part->type == PART_EMITTER) {
-			m_shapes.push_back(new AbcPointsWriter(m_scene, ob, xform, m_shape_sampling_index, m_settings, psys));
-		}
-	}
-
 	switch(ob->type) {
 		case OB_MESH:
 		{

source/blender/alembic/intern/abc_hair.cc

@@ -37,7 +37,6 @@ extern "C" {
 
 #include "BKE_DerivedMesh.h"
 #include "BKE_object.h"
-#include "BKE_particle.h"
 }
 
 using Alembic::Abc::P3fArraySamplePtr;
@@ -54,10 +53,10 @@ AbcHairWriter::AbcHairWriter(Scene *scene,
                              AbcTransformWriter *parent,
                              uint32_t time_sampling,
                              ExportSettings &settings,
-                             ParticleSystem *psys)
+                             void *UNUSED(psys))
     : AbcObjectWriter(scene, ob, time_sampling, settings, parent)
 {
-	m_psys = psys;
+	m_psys = NULL; // = psys;
 
 	OCurves curves(parent->alembicXform(), m_name, m_time_sampling);
 	m_schema = curves.getSchema();
@@ -68,7 +67,7 @@ void AbcHairWriter::do_write()
 	if (!m_psys) {
 		return;
 	}
-
+#if 0
 	ParticleSystemModifierData *psmd = psys_get_modifier(m_object, m_psys);
 
 	if (!psmd->dm_final) {
@@ -116,15 +115,17 @@ void AbcHairWriter::do_write()
 
 	m_sample.setSelfBounds(bounds());
 	m_schema.set(m_sample);
+#endif
 }
 
 void AbcHairWriter::write_hair_sample(DerivedMesh *dm,
-                                      ParticleSettings *part,
+                                      void *part,
                                       std::vector<Imath::V3f> &verts,
                                       std::vector<Imath::V3f> &norm_values,
                                       std::vector<Imath::V2f> &uv_values,
                                       std::vector<int32_t> &hvertices)
 {
+#if 0
 	/* Get untransformed vertices, there's a xform under the hair. */
 	float inv_mat[4][4];
 	invert_m4_m4_safe(inv_mat, m_object->obmat);
@@ -225,15 +226,17 @@ void AbcHairWriter::write_hair_sample(DerivedMesh *dm,
 			++path;
 		}
 	}
+#endif
 }
 
 void AbcHairWriter::write_hair_child_sample(DerivedMesh *dm,
-                                            ParticleSettings *part,
+                                            void *part,
                                             std::vector<Imath::V3f> &verts,
                                             std::vector<Imath::V3f> &norm_values,
                                             std::vector<Imath::V2f> &uv_values,
                                             std::vector<int32_t> &hvertices)
 {
+#if 0
 	/* Get untransformed vertices, there's a xform under the hair. */
 	float inv_mat[4][4];
 	invert_m4_m4_safe(inv_mat, m_object->obmat);
@@ -287,4 +290,5 @@ void AbcHairWriter::write_hair_child_sample(DerivedMesh *dm,
 			++path;
 		}
 	}
+#endif
 }

source/blender/alembic/intern/abc_hair.h

@@ -26,13 +26,11 @@
 #include "abc_object.h"
 
 struct DerivedMesh;
-struct ParticleSettings;
-struct ParticleSystem;
 
 /* ************************************************************************** */
 
 class AbcHairWriter : public AbcObjectWriter {
-	ParticleSystem *m_psys;
+	/*ParticleSystem*/ void *m_psys;
 
 	Alembic::AbcGeom::OCurvesSchema m_schema;
 	Alembic::AbcGeom::OCurvesSchema::Sample m_sample;
@@ -43,20 +41,20 @@ public:
 	              AbcTransformWriter *parent,
 	              uint32_t time_sampling,
 	              ExportSettings &settings,
-	              ParticleSystem *psys);
+	              /*ParticleSystem*/void *psys);
 
 private:
 	virtual void do_write();
 
 	void write_hair_sample(DerivedMesh *dm,
-	                       ParticleSettings *part,
+	                       /*ParticleSettings*/ void *part,
 	                       std::vector<Imath::V3f> &verts,
 	                       std::vector<Imath::V3f> &norm_values,
 	                       std::vector<Imath::V2f> &uv_values,
 	                       std::vector<int32_t> &hvertices);
 
 	void write_hair_child_sample(DerivedMesh *dm,
-	                             ParticleSettings *part,
+	                             /*ParticleSettings*/ void *part,
 	                             std::vector<Imath::V3f> &verts,
 	                             std::vector<Imath::V3f> &norm_values,
 	                             std::vector<Imath::V2f> &uv_values,

source/blender/alembic/intern/abc_mesh.cc

@@ -272,7 +272,7 @@ static ModifierData *get_subsurf_modifier(Scene *scene, Object *ob)
 		}
 
 		/* mesh is not a subsurf. break */
-		if ((md->type != eModifierType_Displace) && (md->type != eModifierType_ParticleSystem)) {
+		if ((md->type != eModifierType_Displace) /*&& (md->type != eModifierType_ParticleSystem)*/) {
 			return NULL;
 		}
 	}
@@ -968,7 +968,8 @@ AbcMeshReader::AbcMeshReader(const IObject &object, ImportSettings &settings)
 
 	IPolyMesh ipoly_mesh(m_iobject, kWrapExisting);
 	m_schema = ipoly_mesh.getSchema();
-	get_min_max_time(m_schema, m_min_time, m_max_time);
+
+	get_min_max_time(m_iobject, m_schema, m_min_time, m_max_time);
 }
 
 bool AbcMeshReader::valid() const
@@ -1120,7 +1121,8 @@ AbcSubDReader::AbcSubDReader(const IObject &object, ImportSettings &settings)
 
 	ISubD isubd_mesh(m_iobject, kWrapExisting);
 	m_schema = isubd_mesh.getSchema();
-	get_min_max_time(m_schema, m_min_time, m_max_time);
+
+	get_min_max_time(m_iobject, m_schema, m_min_time, m_max_time);
 }
 
 bool AbcSubDReader::valid() const

source/blender/alembic/intern/abc_nurbs.cc

@@ -201,7 +201,7 @@ AbcNurbsReader::AbcNurbsReader(const IObject &object, ImportSettings &settings)
     : AbcObjectReader(object, settings)
 {
 	getNurbsPatches(m_iobject);
-	get_min_max_time(m_schemas[0].first, m_min_time, m_max_time);
+	get_min_max_time(m_iobject, m_schemas[0].first, m_min_time, m_max_time);
 }
 
 bool AbcNurbsReader::valid() const

source/blender/alembic/intern/abc_points.cc

@@ -30,11 +30,11 @@
 
 extern "C" {
 #include "DNA_mesh_types.h"
+#include "DNA_object_types.h"
 
 #include "BKE_lattice.h"
 #include "BKE_mesh.h"
 #include "BKE_object.h"
-#include "BKE_particle.h"
 #include "BKE_scene.h"
 
 #include "BLI_math.h"
@@ -61,10 +61,10 @@ AbcPointsWriter::AbcPointsWriter(Scene *scene,
 	                             AbcTransformWriter *parent,
 	                             uint32_t time_sampling,
 	                             ExportSettings &settings,
-	                             ParticleSystem *psys)
+	                             void *UNUSED(psys))
     : AbcObjectWriter(scene, ob, time_sampling, settings, parent)
 {
-	m_psys = psys;
+	m_psys = NULL; // = psys;
 
 	OPoints points(parent->alembicXform(), m_name, m_time_sampling);
 	m_schema = points.getSchema();
@@ -75,7 +75,7 @@ void AbcPointsWriter::do_write()
 	if (!m_psys) {
 		return;
 	}
-
+#if 0
 	std::vector<Imath::V3f> points;
 	std::vector<Imath::V3f> velocities;
 	std::vector<float> widths;
@@ -132,6 +132,7 @@ void AbcPointsWriter::do_write()
 	m_sample.setSelfBounds(bounds());
 
 	m_schema.set(m_sample);
+#endif
 }
 
 /* ************************************************************************** */
@@ -141,7 +142,7 @@ AbcPointsReader::AbcPointsReader(const Alembic::Abc::IObject &object, ImportSett
 {
 	IPoints ipoints(m_iobject, kWrapExisting);
 	m_schema = ipoints.getSchema();
-	get_min_max_time(m_schema, m_min_time, m_max_time);
+	get_min_max_time(m_iobject, m_schema, m_min_time, m_max_time);
 }
 
 bool AbcPointsReader::valid() const

source/blender/alembic/intern/abc_points.h

@@ -28,14 +28,12 @@
 #include "abc_object.h"
 #include "abc_customdata.h"
 
-class ParticleSystem;
-
 /* ************************************************************************** */
 
 class AbcPointsWriter : public AbcObjectWriter {
 	Alembic::AbcGeom::OPointsSchema m_schema;
 	Alembic::AbcGeom::OPointsSchema::Sample m_sample;
-	ParticleSystem *m_psys;
+	/*ParticleSystem*/ void *m_psys;
 
 public:
 	AbcPointsWriter(Scene *scene,
@@ -43,7 +41,7 @@ public:
 	                AbcTransformWriter *parent,
 	                uint32_t time_sampling,
 	                ExportSettings &settings,
-	                ParticleSystem *psys);
+	                /*ParticleSystem*/ void *psys);
 
 	void do_write();
 };

source/blender/alembic/intern/abc_transform.cc

@@ -137,7 +137,7 @@ AbcEmptyReader::AbcEmptyReader(const Alembic::Abc::IObject &object, ImportSettin
 	Alembic::AbcGeom::IXform xform(object, Alembic::AbcGeom::kWrapExisting);
 	m_schema = xform.getSchema();
 
-	get_min_max_time(m_schema, m_min_time, m_max_time);
+	get_min_max_time(m_iobject, m_schema, m_min_time, m_max_time);
 }
 
 bool AbcEmptyReader::valid() const

source/blender/alembic/intern/abc_util.h

@@ -64,7 +64,7 @@ void create_input_transform(const Alembic::AbcGeom::ISampleSelector &sample_sel,
                             float r_mat[4][4], float scale, bool has_alembic_parent = false);
 
 template <typename Schema>
-void get_min_max_time(const Schema &schema, chrono_t &min, chrono_t &max)
+void get_min_max_time_ex(const Schema &schema, chrono_t &min, chrono_t &max)
 {
 	const Alembic::Abc::TimeSamplingPtr &time_samp = schema.getTimeSampling();
 
@@ -81,6 +81,18 @@ void get_min_max_time(const Schema &schema, chrono_t &min, chrono_t &max)
 	}
 }
 
+template <typename Schema>
+void get_min_max_time(const Alembic::AbcGeom::IObject &object, const Schema &schema, chrono_t &min, chrono_t &max)
+{
+	get_min_max_time_ex(schema, min, max);
+
+	const Alembic::AbcGeom::IObject &parent = object.getParent();
+	if (parent.valid() && Alembic::AbcGeom::IXform::matches(parent.getMetaData())) {
+		Alembic::AbcGeom::IXform xform(parent, Alembic::AbcGeom::kWrapExisting);
+		get_min_max_time_ex(xform.getSchema(), min, max);
+	}
+}
+
 bool has_property(const Alembic::Abc::ICompoundProperty &prop, const std::string &name);
 
 /* ************************** */

source/blender/alembic/intern/alembic_capi.cc

@@ -585,6 +585,9 @@ static void import_startjob(void *user_data, short *stop, short *do_update, floa
 	IArchive *archive = open_archive(data->filename);
 
 	if (!archive || !archive->valid()) {
+		if (archive) {
+			delete archive;
+		}
 		data->error_code = ABC_ARCHIVE_FAIL;
 		return;
 	}
@@ -933,12 +936,12 @@ static DerivedMesh *read_mesh_sample(DerivedMesh *dm, const IObject &iobject, co
 
 	CDStreamConfig config = get_config(new_dm ? new_dm : dm);
 
-	bool has_loop_normals = false;
-	read_mesh_sample(&settings, schema, sample_sel, config, has_loop_normals);
+	bool do_normals = false;
+	read_mesh_sample(&settings, schema, sample_sel, config, do_normals);
 
 	if (new_dm) {
 		/* Check if we had ME_SMOOTH flag set to restore it. */
-		if (!has_loop_normals && check_smooth_poly_flag(dm)) {
+		if (!do_normals && check_smooth_poly_flag(dm)) {
 			set_smooth_poly_flag(new_dm);
 		}
 
@@ -948,6 +951,10 @@ static DerivedMesh *read_mesh_sample(DerivedMesh *dm, const IObject &iobject, co
 		return new_dm;
 	}
 
+	if (do_normals) {
+		CDDM_calc_normals(dm);
+	}
+
 	return dm;
 }
 

source/blender/blenkernel/BKE_collision.h

@@ -146,6 +146,10 @@ void collision_get_collider_velocity(float vel_old[3], float vel_new[3], struct
 /////////////////////////////////////////////////
 // used in effect.c
 /////////////////////////////////////////////////
+
+/* explicit control over layer mask and dupli recursion */
+struct Object **get_collisionobjects_ext(struct Scene *scene, struct Object *self, struct Group *group, int layer, unsigned int *numcollobj, unsigned int modifier_type, bool dupli);
+
 struct Object **get_collisionobjects(struct Scene *scene, struct Object *self, struct Group *group, unsigned int *numcollobj, unsigned int modifier_type);
 
 typedef struct ColliderCache {

source/blender/blenkernel/BKE_effect.h

@@ -60,6 +60,8 @@ typedef struct EffectedPoint {
 
 	unsigned int flag;
 	int index;
+
+	struct ParticleSystem *psys;  /* particle system the point belongs to */
 } EffectedPoint;
 
 typedef struct GuideEffectorData {
@@ -105,7 +107,7 @@ typedef struct EffectorCache {
 } EffectorCache;
 
 void            free_partdeflect(struct PartDeflect *pd);
-struct ListBase *pdInitEffectors(struct Scene *scene, struct Object *ob_src, struct EffectorWeights *weights, bool precalc);
+struct ListBase *pdInitEffectors(struct Scene *scene, struct Object *ob_src, struct EffectorWeights *weights, bool for_simulation);
 void            pdEndEffectors(struct ListBase **effectors);
 void            pdPrecalculateEffectors(struct ListBase *effectors);
 void            pdDoEffectors(struct ListBase *effectors, struct ListBase *colliders, struct EffectorWeights *weights, struct EffectedPoint *point, float *force, float *impulse);

source/blender/blenkernel/BKE_material.h

@@ -49,7 +49,7 @@ void BKE_material_free(struct Material *ma);
 void BKE_material_free_ex(struct Material *ma, bool do_id_user);
 void test_object_materials(struct Object *ob, struct ID *id);
 void test_all_objects_materials(struct Main *bmain, struct ID *id);
-void BKE_material_resize_object(struct Object *ob, const short totcol, bool do_id_user);
+void BKE_material_resize_object(struct Main *bmain, struct Object *ob, const short totcol, bool do_id_user);
 void BKE_material_init(struct Material *ma);
 void BKE_material_remap_object(struct Object *ob, const unsigned int *remap);
 void BKE_material_remap_object_calc(struct  Object *ob_dst, struct Object *ob_src, short *remap_src_to_dst);
@@ -90,10 +90,10 @@ void BKE_texpaint_slot_refresh_cache(struct Scene *scene, struct Material *ma);
 void BKE_texpaint_slots_refresh_object(struct Scene *scene, struct Object *ob);
 
 /* rna api */
-void BKE_material_resize_id(struct ID *id, short totcol, bool do_id_user);
-void BKE_material_append_id(struct ID *id, struct Material *ma);
-struct Material *BKE_material_pop_id(struct ID *id, int index, bool update_data); /* index is an int because of RNA */
-void BKE_material_clear_id(struct ID *id, bool update_data);
+void BKE_material_resize_id(struct Main *bmain, struct ID *id, short totcol, bool do_id_user);
+void BKE_material_append_id(struct Main *bmain, struct ID *id, struct Material *ma);
+struct Material *BKE_material_pop_id(struct Main *bmain, struct ID *id, int index, bool update_data); /* index is an int because of RNA */
+void BKE_material_clear_id(struct Main *bmain, struct ID *id, bool update_data);
 /* rendering */
 
 void init_render_material(struct Material *, int, float *);

source/blender/blenkernel/BKE_tracking.h

@@ -277,9 +277,9 @@ void BKE_tracking_detect_harris(struct MovieTracking *tracking, struct ListBase
                                 bool place_outside_layer);
 
 /* **** 2D stabilization **** */
-void BKE_tracking_stabilization_data_get(struct MovieTracking *tracking, int framenr, int width, int height,
+void BKE_tracking_stabilization_data_get(struct MovieClip *clip, int framenr, int width, int height,
                                          float translation[2], float *scale, float *angle);
-struct ImBuf *BKE_tracking_stabilize_frame(struct MovieTracking *tracking, int framenr, struct ImBuf *ibuf,
+struct ImBuf *BKE_tracking_stabilize_frame(struct MovieClip *clip, int framenr, struct ImBuf *ibuf,
                                            float translation[2], float *scale, float *angle);
 void BKE_tracking_stabilization_data_to_mat4(int width, int height, float aspect, float translation[2],
                                              float scale, float angle, float mat[4][4]);

source/blender/blenkernel/depsgraph_private.h

@@ -34,6 +34,11 @@
 #include "DNA_constraint_types.h"
 #include "BKE_constraint.h"
 
+struct Scene;
+struct Group;
+struct EffectorWeights;
+struct ModifierData;
+
 /* **** DAG relation types *** */
 
 /* scene link to object */
@@ -152,6 +157,11 @@ DagNode *dag_get_node(DagForest *forest, void *fob);
 DagNode *dag_get_sub_node(DagForest *forest, void *fob);
 void dag_add_relation(DagForest *forest, DagNode *fob1, DagNode *fob2, short rel, const char *name);
 
+typedef bool (*DagCollobjFilterFunction)(struct Object *obj, struct ModifierData *md);
+
+void dag_add_collision_relations(DagForest *dag, struct Scene *scene, Object *ob, DagNode *node, struct Group *group, int layer, unsigned int modifier_type, DagCollobjFilterFunction fn, bool dupli, const char *name);
+void dag_add_forcefield_relations(DagForest *dag, struct Scene *scene, Object *ob, DagNode *node, struct EffectorWeights *eff, bool add_absorption, int skip_forcefield, const char *name);
+
 void graph_print_queue(DagNodeQueue *nqueue);
 void graph_print_queue_dist(DagNodeQueue *nqueue);
 void graph_print_adj_list(DagForest *dag);

source/blender/blenkernel/intern/anim_sys.c

@@ -1506,7 +1506,7 @@ static bool animsys_store_rna_setting(
 				if (array_len && array_index >= array_len) {
 					if (G.debug & G_DEBUG) {
 						printf("Animato: Invalid array index. ID = '%s',  '%s[%d]', array length is %d\n",
-						       (ptr && ptr->id.data) ? (((ID *)ptr->id.data)->name + 2) : "<No ID>",
+						       (ptr->id.data) ? (((ID *)ptr->id.data)->name + 2) : "<No ID>",
 						       path, array_index, array_len - 1);
 					}
 				}

source/blender/blenkernel/intern/cdderivedmesh.c

@@ -687,20 +687,24 @@ static void cdDM_drawMappedFaces(
 					const int orig = (index_mp_to_orig) ? index_mp_to_orig[i] : i;
 					bool is_hidden;
 
-					if (use_hide) {
-						if (flag & DM_DRAW_SELECT_USE_EDITMODE) {
-							BMFace *efa = BM_face_at_index(bm, orig);
-							is_hidden = BM_elem_flag_test(efa, BM_ELEM_HIDDEN) != 0;
+					if (orig != ORIGINDEX_NONE) {
+						if (use_hide) {
+							if (flag & DM_DRAW_SELECT_USE_EDITMODE) {
+								BMFace *efa = BM_face_at_index(bm, orig);
+								is_hidden = BM_elem_flag_test(efa, BM_ELEM_HIDDEN) != 0;
+							}
+							else {
+								is_hidden = (me->mpoly[orig].flag & ME_HIDE) != 0;
+							}
+
+							if (!is_hidden) {
+								GPU_select_index_get(orig + 1, &selcol);
+							}
 						}
 						else {
-							is_hidden = (me->mpoly[orig].flag & ME_HIDE) != 0;
-						}
-
-						if ((orig != ORIGINDEX_NONE) && !is_hidden)
 							GPU_select_index_get(orig + 1, &selcol);
+						}
 					}
-					else if (orig != ORIGINDEX_NONE)
-						GPU_select_index_get(orig + 1, &selcol);
 
 					for (j = 0; j < mpoly->totloop; j++)
 						fi_map[start_element++] = selcol;

source/blender/blenkernel/intern/cloth.c

@@ -80,8 +80,10 @@ void cloth_init(ClothModifierData *clmd )
 	clmd->sim_parms->gravity[1] = 0.0;
 	clmd->sim_parms->gravity[2] = -9.81;
 	clmd->sim_parms->structural = 15.0;
+	clmd->sim_parms->max_struct = 15.0;
 	clmd->sim_parms->shear = 15.0;
 	clmd->sim_parms->bending = 0.5;
+	clmd->sim_parms->max_bend = 0.5;
 	clmd->sim_parms->bending_damping = 0.5;
 	clmd->sim_parms->Cdis = 5.0; 
 	clmd->sim_parms->Cvi = 1.0;

source/blender/blenkernel/intern/collision.c

@@ -503,12 +503,13 @@ static void add_collision_object(Object ***objs, unsigned int *numobj, unsigned
 
 // return all collision objects in scene
 // collision object will exclude self 
-Object **get_collisionobjects(Scene *scene, Object *self, Group *group, unsigned int *numcollobj, unsigned int modifier_type)
+Object **get_collisionobjects_ext(Scene *scene, Object *self, Group *group, int layer, unsigned int *numcollobj, unsigned int modifier_type, bool dupli)
 {
 	Base *base;
 	Object **objs;
 	GroupObject *go;
 	unsigned int numobj= 0, maxobj= 100;
+	int level = dupli ? 0 : 1;
 	
 	objs= MEM_callocN(sizeof(Object *)*maxobj, "CollisionObjectsArray");
 
@@ -516,16 +517,14 @@ Object **get_collisionobjects(Scene *scene, Object *self, Group *group, unsigned
 	if (group) {
 		/* use specified group */
 		for (go= group->gobject.first; go; go= go->next)
-			add_collision_object(&objs, &numobj, &maxobj, go->ob, self, 0, modifier_type);
+			add_collision_object(&objs, &numobj, &maxobj, go->ob, self, level, modifier_type);
 	}
 	else {
 		Scene *sce_iter;
 		/* add objects in same layer in scene */
 		for (SETLOOPER(scene, sce_iter, base)) {
-			/* Need to check for active layers, too.
-			Otherwise this check fails if the objects are not on the same layer - DG */
-			if ((base->lay & self->lay) || (base->lay & scene->lay))
-				add_collision_object(&objs, &numobj, &maxobj, base->object, self, 0, modifier_type);
+			if ( base->lay & layer )
+				add_collision_object(&objs, &numobj, &maxobj, base->object, self, level, modifier_type);
 
 		}
 	}
@@ -535,6 +534,13 @@ Object **get_collisionobjects(Scene *scene, Object *self, Group *group, unsigned
 	return objs;
 }
 
+Object **get_collisionobjects(Scene *scene, Object *self, Group *group, unsigned int *numcollobj, unsigned int modifier_type)
+{
+	/* Need to check for active layers, too.
+	   Otherwise this check fails if the objects are not on the same layer - DG */
+	return get_collisionobjects_ext(scene, self, group, self->lay | scene->lay, numcollobj, modifier_type, true);
+}
+
 static void add_collider_cache_object(ListBase **objs, Object *ob, Object *self, int level)
 {
 	CollisionModifierData *cmd= NULL;

source/blender/blenkernel/intern/depsgraph.c

@@ -61,11 +61,14 @@
 #include "DNA_windowmanager_types.h"
 #include "DNA_movieclip_types.h"
 #include "DNA_mask_types.h"
+#include "DNA_modifier_types.h"
+#include "DNA_rigidbody_types.h"
 
 #include "BKE_anim.h"
 #include "BKE_animsys.h"
 #include "BKE_action.h"
 #include "BKE_DerivedMesh.h"
+#include "BKE_collision.h"
 #include "BKE_effect.h"
 #include "BKE_fcurve.h"
 #include "BKE_global.h"
@@ -450,29 +453,51 @@ static void dag_add_lamp_driver_relations(DagForest *dag, DagNode *node, Lamp *l
 	la->id.tag &= ~LIB_TAG_DOIT;
 }
 
-static void check_and_create_collision_relation(DagForest *dag, Object *ob, DagNode *node, Object *ob1, int skip_forcefield, bool no_collision)
+static void create_collision_relation(DagForest *dag, DagNode *node, Object *ob1, const char *name)
 {
-	DagNode *node2;
-	if (ob1->pd && (ob1->pd->deflect || ob1->pd->forcefield) && (ob1 != ob)) {
-		if ((skip_forcefield && ob1->pd->forcefield == skip_forcefield) || (no_collision && ob1->pd->forcefield == 0))
-			return;
-		node2 = dag_get_node(dag, ob1);
-		dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Field Collision");
-	}
+	DagNode *node2 = dag_get_node(dag, ob1);
+	dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, name);
 }
 
-static void dag_add_collision_field_relation(DagForest *dag, Scene *scene, Object *ob, DagNode *node, int skip_forcefield, bool no_collision)
+void dag_add_collision_relations(DagForest *dag, Scene *scene, Object *ob, DagNode *node, Group *group, int layer, unsigned int modifier_type, DagCollobjFilterFunction fn, bool dupli, const char *name)
 {
-	Base *base;
+	unsigned int numcollobj;
+	Object **collobjs = get_collisionobjects_ext(scene, ob, group, layer, &numcollobj, modifier_type, dupli);
 
-	/* would be nice to have a list of colliders here
-	 * so for now walk all objects in scene check 'same layer rule' */
-	for (base = scene->base.first; base; base = base->next) {
-		if ((base->lay & ob->lay)) {
-			Object *ob1 = base->object;
-			check_and_create_collision_relation(dag, ob, node, ob1, skip_forcefield, no_collision);
+	for (unsigned int i = 0; i < numcollobj; i++) {
+		Object *ob1 = collobjs[i];
+
+		if (!fn || fn(ob1, modifiers_findByType(ob1, modifier_type))) {
+			create_collision_relation(dag, node, ob1, name);
 		}
 	}
+
+	if (collobjs)
+		MEM_freeN(collobjs);
+}
+
+void dag_add_forcefield_relations(DagForest *dag, Scene *scene, Object *ob, DagNode *node, EffectorWeights *effector_weights, bool add_absorption, int skip_forcefield, const char *name)
+{
+	ListBase *effectors = pdInitEffectors(scene, ob, effector_weights, false);
+
+	if (effectors) {
+		for (EffectorCache *eff = effectors->first; eff; eff = eff->next) {
+			if (eff->ob != ob && eff->pd->forcefield != skip_forcefield) {
+				create_collision_relation(dag, node, eff->ob, name);
+
+				if (eff->pd->forcefield == PFIELD_SMOKEFLOW && eff->pd->f_source) {
+					create_collision_relation(dag, node, eff->pd->f_source, "Smoke Force Domain");
+				}
+
+				if (add_absorption && (eff->pd->flag & PFIELD_VISIBILITY)) {
+					/* Actual code uses get_collider_cache */
+					dag_add_collision_relations(dag, scene, ob, node, NULL, eff->ob->lay, eModifierType_Collision, NULL, true, "Force Absorption");
+				}
+			}
+		}
+	}
+
+	pdEndEffectors(&effectors);
 }
 
 static void build_dag_object(DagForest *dag, DagNode *scenenode, Main *bmain, Scene *scene, Object *ob, int mask)
@@ -622,22 +647,13 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Main *bmain, Sc
 		}
 	}
 
-	/* softbody collision  */
+	/* rigidbody force fields  */
 	if ((ob->type == OB_MESH) || (ob->type == OB_CURVE) || (ob->type == OB_LATTICE)) {
-		if (modifiers_isModifierEnabled(ob, eModifierType_Softbody) ||
-		    modifiers_isModifierEnabled(ob, eModifierType_Cloth) ||
-		    modifiers_isModifierEnabled(ob, eModifierType_DynamicPaint))
-		{
-			dag_add_collision_field_relation(dag, scene, ob, node, 0, false);  /* TODO: use effectorweight->group */
-		}
-		else if (modifiers_isModifierEnabled(ob, eModifierType_Smoke)) {
-			dag_add_collision_field_relation(dag, scene, ob, node, PFIELD_SMOKEFLOW, false);
-		}
-		else if (ob->rigidbody_object) {
-			dag_add_collision_field_relation(dag, scene, ob, node, 0, true);
+		if (ob->rigidbody_object && scene->rigidbody_world) {
+			dag_add_forcefield_relations(dag, scene, ob, node, scene->rigidbody_world->effector_weights, true, 0, "Force Field");
 		}
 	}
-	
+
 	/* object data drivers */
 	if (ob->data) {
 		AnimData *adt = BKE_animdata_from_id((ID *)ob->data);

source/blender/blenkernel/intern/effect.c

@@ -152,15 +152,20 @@ static EffectorCache *new_effector_cache(Scene *scene, Object *ob, PartDeflect *
 	eff->frame = -1;
 	return eff;
 }
-static void add_object_to_effectors(ListBase **effectors, Scene *scene, EffectorWeights *weights, Object *ob, Object *ob_src)
+static void add_object_to_effectors(ListBase **effectors, Scene *scene, EffectorWeights *weights, Object *ob, Object *ob_src, bool for_simulation)
 {
 	EffectorCache *eff = NULL;
 
-	if ( ob == ob_src || weights->weight[ob->pd->forcefield] == 0.0f )
+	if ( ob == ob_src )
 		return;
 
-	if (ob->pd->shape == PFIELD_SHAPE_POINTS && !ob->derivedFinal )
-		return;
+	if (for_simulation) {
+		if (weights->weight[ob->pd->forcefield] == 0.0f )
+			return;
+
+		if (ob->pd->shape == PFIELD_SHAPE_POINTS && !ob->derivedFinal )
+			return;
+	}
 
 	if (*effectors == NULL)
 		*effectors = MEM_callocN(sizeof(ListBase), "effectors list");
@@ -175,7 +180,7 @@ static void add_object_to_effectors(ListBase **effectors, Scene *scene, Effector
 
 /* returns ListBase handle with objects taking part in the effecting */
 ListBase *pdInitEffectors(Scene *scene, Object *ob_src,
-                          EffectorWeights *weights, bool precalc)
+                          EffectorWeights *weights, bool for_simulation)
 {
 	Base *base;
 	unsigned int layer= ob_src->lay;
@@ -187,7 +192,7 @@ ListBase *pdInitEffectors(Scene *scene, Object *ob_src,
 		for (go= weights->group->gobject.first; go; go= go->next) {
 			if ( (go->ob->lay & layer) ) {
 				if ( go->ob->pd && go->ob->pd->forcefield )
-					add_object_to_effectors(&effectors, scene, weights, go->ob, ob_src);
+					add_object_to_effectors(&effectors, scene, weights, go->ob, ob_src, for_simulation);
 			}
 		}
 	}
@@ -195,12 +200,12 @@ ListBase *pdInitEffectors(Scene *scene, Object *ob_src,
 		for (base = scene->base.first; base; base= base->next) {
 			if ( (base->lay & layer) ) {
 				if ( base->object->pd && base->object->pd->forcefield )
-					add_object_to_effectors(&effectors, scene, weights, base->object, ob_src);
+					add_object_to_effectors(&effectors, scene, weights, base->object, ob_src, for_simulation);
 			}
 		}
 	}
 	
-	if (precalc)
+	if (for_simulation)
 		pdPrecalculateEffectors(effectors);
 	
 	return effectors;

source/blender/blenkernel/intern/gpencil.c

@@ -1268,7 +1268,7 @@ void BKE_gpencil_palettecolor_changename(bGPdata *gpd, char *oldname, const char
 		for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
 			for (gps = gpf->strokes.first; gps; gps = gps->next) {
 				if (STREQ(gps->colorname, oldname)) {
-					strcpy(gps->colorname, newname);
+					BLI_strncpy(gps->colorname, newname, sizeof(gps->colorname));
 				}
 			}
 		}

source/blender/blenkernel/intern/material.c

@@ -58,6 +58,7 @@
 #include "BKE_animsys.h"
 #include "BKE_displist.h"
 #include "BKE_global.h"
+#include "BKE_depsgraph.h"
 #include "BKE_icons.h"
 #include "BKE_image.h"
 #include "BKE_library.h"
@@ -398,7 +399,7 @@ static void material_data_index_clear_id(ID *id)
 	}
 }
 
-void BKE_material_resize_id(struct ID *id, short totcol, bool do_id_user)
+void BKE_material_resize_id(Main *bmain, ID *id, short totcol, bool do_id_user)
 {
 	Material ***matar = give_matarar_id(id);
 	short *totcolp = give_totcolp_id(id);
@@ -424,9 +425,11 @@ void BKE_material_resize_id(struct ID *id, short totcol, bool do_id_user)
 		*matar = MEM_recallocN(*matar, sizeof(void *) * totcol);
 	}
 	*totcolp = totcol;
+
+	DAG_relations_tag_update(bmain);
 }
 
-void BKE_material_append_id(ID *id, Material *ma)
+void BKE_material_append_id(Main *bmain, ID *id, Material *ma)
 {
 	Material ***matar;
 	if ((matar = give_matarar_id(id))) {
@@ -439,11 +442,12 @@ void BKE_material_append_id(ID *id, Material *ma)
 		(*matar)[(*totcol)++] = ma;
 
 		id_us_plus((ID *)ma);
-		test_all_objects_materials(G.main, id);
+		test_all_objects_materials(bmain, id);
+		DAG_relations_tag_update(bmain);
 	}
 }
 
-Material *BKE_material_pop_id(ID *id, int index_i, bool update_data)
+Material *BKE_material_pop_id(Main *bmain, ID *id, int index_i, bool update_data)
 {
 	short index = (short)index_i;
 	Material *ret = NULL;
@@ -472,13 +476,15 @@ Material *BKE_material_pop_id(ID *id, int index_i, bool update_data)
 				/* decrease mat_nr index */
 				material_data_index_remove_id(id, index);
 			}
+
+			DAG_relations_tag_update(bmain);
 		}
 	}
 	
 	return ret;
 }
 
-void BKE_material_clear_id(struct ID *id, bool update_data)
+void BKE_material_clear_id(Main *bmain, ID *id, bool update_data)
 {
 	Material ***matar;
 	if ((matar = give_matarar_id(id))) {
@@ -497,6 +503,8 @@ void BKE_material_clear_id(struct ID *id, bool update_data)
 			/* decrease mat_nr index */
 			material_data_index_clear_id(id);
 		}
+
+		DAG_relations_tag_update(bmain);
 	}
 }
 
@@ -553,7 +561,7 @@ Material *give_node_material(Material *ma)
 	return NULL;
 }
 
-void BKE_material_resize_object(Object *ob, const short totcol, bool do_id_user)
+void BKE_material_resize_object(Main *bmain, Object *ob, const short totcol, bool do_id_user)
 {
 	Material **newmatar;
 	char *newmatbits;
@@ -590,6 +598,8 @@ void BKE_material_resize_object(Object *ob, const short totcol, bool do_id_user)
 	ob->totcol = totcol;
 	if (ob->totcol && ob->actcol == 0) ob->actcol = 1;
 	if (ob->actcol > ob->totcol) ob->actcol = ob->totcol;
+
+	DAG_relations_tag_update(bmain);
 }
 
 void test_object_materials(Object *ob, ID *id)
@@ -601,7 +611,7 @@ void test_object_materials(Object *ob, ID *id)
 		return;
 	}
 
-	BKE_material_resize_object(ob, *totcol, false);
+	BKE_material_resize_object(G.main, ob, *totcol, false);
 }
 
 void test_all_objects_materials(Main *bmain, ID *id)
@@ -617,7 +627,7 @@ void test_all_objects_materials(Main *bmain, ID *id)
 	BKE_main_lock(bmain);
 	for (ob = bmain->object.first; ob; ob = ob->id.next) {
 		if (ob->data == id) {
-			BKE_material_resize_object(ob, *totcol, false);
+			BKE_material_resize_object(bmain, ob, *totcol, false);
 		}
 	}
 	BKE_main_unlock(bmain);
@@ -1881,7 +1891,7 @@ static short mesh_getmaterialnumber(Mesh *me, Material *ma)
 /* append material */
 static short mesh_addmaterial(Mesh *me, Material *ma)
 {
-	BKE_material_append_id(&me->id, NULL);
+	BKE_material_append_id(G.main, &me->id, NULL);
 	me->mat[me->totcol - 1] = ma;
 
 	id_us_plus(&ma->id);
@@ -2020,7 +2030,7 @@ static void convert_tfacematerial(Main *main, Material *ma)
 		/* remove material from mesh */
 		for (a = 0; a < me->totcol; ) {
 			if (me->mat[a] == ma) {
-				BKE_material_pop_id(&me->id, a, true);
+				BKE_material_pop_id(main, &me->id, a, true);
 			}
 			else {
 				a++;

source/blender/blenkernel/intern/movieclip.c

@@ -1033,7 +1033,7 @@ static ImBuf *get_stable_cached_frame(MovieClip *clip, MovieClipUser *user, ImBu
 
 	stableibuf = cache->stabilized.ibuf;
 
-	BKE_tracking_stabilization_data_get(&clip->tracking, clip_framenr, stableibuf->x, stableibuf->y, tloc, &tscale, &tangle);
+	BKE_tracking_stabilization_data_get(clip, clip_framenr, stableibuf->x, stableibuf->y, tloc, &tscale, &tangle);
 
 	/* check for stabilization parameters */
 	if (tscale != cache->stabilized.scale ||
@@ -1057,7 +1057,7 @@ static ImBuf *put_stabilized_frame_to_cache(MovieClip *clip, MovieClipUser *user
 	float tloc[2], tscale, tangle;
 	int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, framenr);
 
-	stableibuf = BKE_tracking_stabilize_frame(&clip->tracking, clip_framenr, ibuf, tloc, &tscale, &tangle);
+	stableibuf = BKE_tracking_stabilize_frame(clip, clip_framenr, ibuf, tloc, &tscale, &tangle);
 
 	copy_v2_v2(cache->stabilized.loc, tloc);
 
@@ -1270,8 +1270,6 @@ void BKE_movieclip_reload(MovieClip *clip)
 	/* clear cache */
 	free_buffers(clip);
 
-	clip->tracking.stabilization.ok = false;
-
 	/* update clip source */
 	detect_clip_source(clip);
 

source/blender/blenkernel/intern/object_dupli.c

@@ -221,31 +221,39 @@ static void make_child_duplis(const DupliContext *ctx, void *userdata, MakeChild
 
 	if (ctx->group) {
 		unsigned int lay = ctx->group->layer;
+		int groupid = 0;
 		GroupObject *go;
-		for (go = ctx->group->gobject.first; go; go = go->next) {
+		for (go = ctx->group->gobject.first; go; go = go->next, groupid++) {
 			Object *ob = go->ob;
 
 			if ((ob->lay & lay) && ob != obedit && is_child(ob, parent)) {
+				DupliContext pctx;
+				copy_dupli_context(&pctx, ctx, ctx->object, NULL, groupid, false);
+
 				/* mballs have a different dupli handling */
 				if (ob->type != OB_MBALL)
 					ob->flag |= OB_DONE;  /* doesnt render */
 
-				make_child_duplis_cb(ctx, userdata, ob);
+				make_child_duplis_cb(&pctx, userdata, ob);
 			}
 		}
 	}
 	else {
 		unsigned int lay = ctx->scene->lay;
+		int baseid = 0;
 		Base *base;
-		for (base = ctx->scene->base.first; base; base = base->next) {
+		for (base = ctx->scene->base.first; base; base = base->next, baseid++) {
 			Object *ob = base->object;
 
 			if ((base->lay & lay) && ob != obedit && is_child(ob, parent)) {
+				DupliContext pctx;
+				copy_dupli_context(&pctx, ctx, ctx->object, NULL, baseid, false);
+
 				/* mballs have a different dupli handling */
 				if (ob->type != OB_MBALL)
 					ob->flag |= OB_DONE;  /* doesnt render */
 
-				make_child_duplis_cb(ctx, userdata, ob);
+				make_child_duplis_cb(&pctx, userdata, ob);
 			}
 		}
 	}

source/blender/blenkernel/intern/scene.c

@@ -162,7 +162,6 @@ Scene *BKE_scene_copy(Main *bmain, Scene *sce, int type)
 	
 	if (type == SCE_COPY_EMPTY) {
 		ListBase rl, rv;
-		/* XXX. main should become an arg */
 		scen = BKE_scene_add(bmain, sce->id.name + 2);
 		
 		rl = scen->r.layers;

source/blender/blenkernel/intern/smoke.c

@@ -2458,11 +2458,10 @@ static void smokeModifier_process(SmokeModifierData *smd, Scene *scene, Object *
 		}
 
 		/* only calculate something when we advanced a single frame */
-		if (framenr != (int)smd->time + 1)
-			return;
-
 		/* don't simulate if viewing start frame, but scene frame is not real start frame */
-		if (framenr != scene->r.cfra)
+		bool can_simulate = (framenr == (int)smd->time + 1) && (framenr == scene->r.cfra);
+
+		if (!can_simulate)
 			return;
 
 #ifdef DEBUG_TIME
@@ -2756,9 +2755,15 @@ float smoke_get_velocity_at(struct Object *ob, float position[3], float velocity
 int smoke_get_data_flags(SmokeDomainSettings *sds)
 {
 	int flags = 0;
-	if (smoke_has_heat(sds->fluid)) flags |= SM_ACTIVE_HEAT;
-	if (smoke_has_fuel(sds->fluid)) flags |= SM_ACTIVE_FIRE;
-	if (smoke_has_colors(sds->fluid)) flags |= SM_ACTIVE_COLORS;
+
+	if (sds->fluid) {
+		if (smoke_has_heat(sds->fluid))
+			flags |= SM_ACTIVE_HEAT;
+		if (smoke_has_fuel(sds->fluid))
+			flags |= SM_ACTIVE_FIRE;
+		if (smoke_has_colors(sds->fluid))
+			flags |= SM_ACTIVE_COLORS;
+	}
 
 	return flags;
 }

source/blender/blenkernel/intern/softbody.c

@@ -3696,7 +3696,10 @@ void sbObjectStep(Scene *scene, Object *ob, float cfra, float (*vertexCos)[3], i
 		return;
 	}
 
-	if (framenr!=sb->last_frame+1)
+	/* try to read from cache */
+	bool can_simulate = (framenr == sb->last_frame + 1);
+
+	if (!can_simulate)
 		return;
 
 	softbody_update_positions(ob, sb, vertexCos, numVerts);

source/blender/blenkernel/intern/subsurf_ccg.c

@@ -2707,7 +2707,6 @@ static void ccgDM_drawFacesSolid(DerivedMesh *dm, float (*partial_redraw_planes)
 	GPU_vertex_setup(dm);
 	GPU_normal_setup(dm);
 	GPU_triangle_setup(dm);
-	glShadeModel(GL_SMOOTH);
 	for (a = 0; a < dm->drawObject->totmaterial; a++) {
 		if (!setMaterial || setMaterial(dm->drawObject->materials[a].mat_nr + 1, NULL)) {
 			GPU_buffer_draw_elements(dm->drawObject->triangles, GL_TRIANGLES, dm->drawObject->materials[a].start,
@@ -2811,8 +2810,6 @@ static void ccgDM_drawMappedFacesGLSL(DerivedMesh *dm,
 	}
 #endif
 
-	glShadeModel(GL_SMOOTH);
-
 	CCG_key_top_level(&key, ss);
 	ccgdm_pbvh_update(ccgdm);
 
@@ -2965,6 +2962,7 @@ static void ccgDM_drawMappedFacesGLSL(DerivedMesh *dm,
 			}
 		}
 
+		glShadeModel(GL_SMOOTH);
 #undef PASSATTRIB
 	}
 	else {
@@ -3170,8 +3168,6 @@ static void ccgDM_drawMappedFacesGLSL(DerivedMesh *dm,
 		MEM_freeN(mat_orig_to_new);
 		MEM_freeN(matconv);
 	}
-
-	glShadeModel(GL_SMOOTH);
 }
 
 static void ccgDM_drawFacesGLSL(DerivedMesh *dm, DMSetMaterial setMaterial)
@@ -3369,6 +3365,7 @@ static void ccgDM_drawMappedFacesMat(DerivedMesh *dm,
 		}
 	}
 
+	glShadeModel(GL_SMOOTH);
 #undef PASSATTRIB
 }
 
@@ -3503,7 +3500,6 @@ static void ccgDM_drawFacesTex_common(DerivedMesh *dm,
 
 	next_actualFace = 0;
 
-	glShadeModel(GL_SMOOTH);
 	/* lastFlag = 0; */ /* UNUSED */
 	for (mat_index = 0; mat_index < dm->drawObject->totmaterial; mat_index++) {
 		GPUBufferMaterial *bufmat = dm->drawObject->materials + mat_index;
@@ -3681,8 +3677,8 @@ static void ccgDM_drawMappedFaces(DerivedMesh *dm,
 		if (do_draw) {
 			glShadeModel(draw_smooth ? GL_SMOOTH : GL_FLAT);
 			ccgSubSurf_drawGLMesh(ss, true, -1, -1);
+			glShadeModel(GL_SMOOTH);
 		}
-		glShadeModel(GL_SMOOTH);
 		return;
 	}
 #endif
@@ -3744,10 +3740,6 @@ static void ccgDM_drawMappedFaces(DerivedMesh *dm,
 					GPU_basic_shader_stipple(GPU_SHADER_STIPPLE_QUARTTONE);
 				}
 
-				/* no need to set shading mode to flat because
-				 *  normals are already used to change shading */
-				glShadeModel(GL_SMOOTH);
-				
 				for (S = 0; S < numVerts; S++) {
 					CCGElem *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
 					if (ln) {

source/blender/blenkernel/intern/tracking.c

@@ -241,13 +241,9 @@ static void tracking_reconstruction_copy(
 
 /* Copy stabilization structure. */
 static void tracking_stabilization_copy(
-        MovieTrackingStabilization *stabilization_dst, MovieTrackingStabilization *stabilization_src,
-        GHash *tracks_mapping)
+        MovieTrackingStabilization *stabilization_dst, MovieTrackingStabilization *stabilization_src)
 {
 	*stabilization_dst = *stabilization_src;
-	if (stabilization_src->rot_track) {
-		stabilization_dst->rot_track = BLI_ghash_lookup(tracks_mapping, stabilization_src->rot_track);
-	}
 }
 
 /* Copy tracking object. */
@@ -284,7 +280,7 @@ void BKE_tracking_copy(MovieTracking *tracking_dst, MovieTracking *tracking_src)
 	tracking_tracks_copy(&tracking_dst->tracks, &tracking_src->tracks, tracks_mapping);
 	tracking_plane_tracks_copy(&tracking_dst->plane_tracks, &tracking_src->plane_tracks, tracks_mapping);
 	tracking_reconstruction_copy(&tracking_dst->reconstruction, &tracking_src->reconstruction);
-	tracking_stabilization_copy(&tracking_dst->stabilization, &tracking_src->stabilization, tracks_mapping);
+	tracking_stabilization_copy(&tracking_dst->stabilization, &tracking_src->stabilization);
 	if (tracking_src->act_track) {
 		tracking_dst->act_track = BLI_ghash_lookup(tracks_mapping, tracking_src->act_track);
 	}
@@ -316,7 +312,7 @@ void BKE_tracking_copy(MovieTracking *tracking_dst, MovieTracking *tracking_src)
 }
 
 /* Initialize motion tracking settings to default values,
- * used when new movie clip datablock is creating.
+ * used when new movie clip datablock is created.
  */
 void BKE_tracking_settings_init(MovieTracking *tracking)
 {
@@ -333,11 +329,23 @@ void BKE_tracking_settings_init(MovieTracking *tracking)
 	tracking->settings.dist = 1;
 	tracking->settings.object_distance = 1;
 
+	tracking->stabilization.scaleinf = 1.0f;
+	tracking->stabilization.anchor_frame = MINFRAME;
+	zero_v2(tracking->stabilization.target_pos);
+	tracking->stabilization.target_rot = 0.0f;
+	tracking->stabilization.scale = 1.0f;
+
+	tracking->stabilization.act_track = 0;
+	tracking->stabilization.act_rot_track = 0;
+	tracking->stabilization.tot_track = 0;
+	tracking->stabilization.tot_rot_track = 0;
+
 	tracking->stabilization.scaleinf = 1.0f;
 	tracking->stabilization.locinf = 1.0f;
 	tracking->stabilization.rotinf = 1.0f;
 	tracking->stabilization.maxscale = 2.0f;
 	tracking->stabilization.filter = TRACKING_FILTER_BILINEAR;
+	tracking->stabilization.flag |= TRACKING_SHOW_STAB_TRACKS;
 
 	BKE_tracking_object_add(tracking, "Camera");
 }
@@ -552,6 +560,7 @@ MovieTrackingTrack *BKE_tracking_track_add(MovieTracking *tracking, ListBase *tr
 	track->flag = settings->default_flag;
 	track->algorithm_flag = settings->default_algorithm_flag;
 	track->weight = settings->default_weight;
+	track->weight_stab = settings->default_weight;
 
 	memset(&marker, 0, sizeof(marker));
 	marker.pos[0] = x;
@@ -590,6 +599,12 @@ MovieTrackingTrack *BKE_tracking_track_duplicate(MovieTrackingTrack *track)
 
 	new_track->markers = MEM_dupallocN(new_track->markers);
 
+	/* Orevent duplicate from being used for 2D stabilization.
+	 * If necessary, it shall be added explicitly.
+	 */
+	new_track->flag &= ~TRACK_USE_2D_STAB;
+	new_track->flag &= ~TRACK_USE_2D_STAB_ROT;
+
 	return new_track;
 }
 

source/blender/blenkernel/intern/writeffmpeg.c

@@ -1393,7 +1393,7 @@ int BKE_ffmpeg_property_add_string(RenderData *rd, const char *type, const char
 	
 	avcodec_get_context_defaults3(&c, NULL);
 
-	strncpy(name_, str, sizeof(name_));
+	BLI_strncpy(name_, str, sizeof(name_));
 
 	name = name_;
 	while (*name == ' ') name++;