Commits

Dean Giberson  committed 3643fc1 Merge

Merge remote-tracking branch 'origin/animblend' into animblend

  • Participants
  • Parent commits e2d0071, 5eb26d7
  • Branches animblend

Comments (0)

Files changed (302)

File blender/CMakeLists.txt

 option(WITH_PYTHON        "Enable Embedded Python API  (only disable for development)" ON)
 option(WITH_PYTHON_SECURITY "Disables execution of scripts within blend files by default (recommend to leave off)" OFF)
 mark_as_advanced(WITH_PYTHON)  # dont want people disabling this unless they really know what they are doing.
-mark_as_advanced(WITH_PYTHON_SECURITY)  # some distrobutions see this as a security issue, rather than have them patch it, make a build option.
+mark_as_advanced(WITH_PYTHON_SECURITY)  # some distributions see this as a security issue, rather than have them patch it, make a build option.
 
 option(WITH_PYTHON_SAFETY "Enable internal API error checking to track invalid data to prevent crash on access (at the expense of some effeciency, only enable for development)." OFF)
 option(WITH_PYTHON_MODULE "Enable building as a python module which runs without a user interface, like running regular blender in background mode (experimental, only enable for development)" OFF)
 	set(WITH_BOOST ON)
 endif()
 
-# don't store paths to libs for portable distrobution
+# don't store paths to libs for portable distribution
 if(WITH_INSTALL_PORTABLE)
 	set(CMAKE_SKIP_BUILD_RPATH TRUE)
 endif()
 
 		mark_as_advanced(FFMPEG)
 
-		# lame, but until we have propper find module for ffmpeg
+		# lame, but until we have proper find module for ffmpeg
 		set(FFMPEG_INCLUDE_DIRS ${FFMPEG}/include)
 		if(EXISTS "${FFMPEG}/include/ffmpeg/")
 			set(FFMPEG_INCLUDE_DIRS "${FFMPEG_INCLUDE_DIRS} ${FFMPEG}/include/ffmpeg")
 			else()
 				set(Boost_USE_MULTITHREADED ON)
 			endif()
-			find_package(Boost 1.34 COMPONENTS filesystem regex system thread)
+			if(WITH_CYCLES_OSL)
+				find_package(Boost 1.34 COMPONENTS filesystem python3 regex system thread) # osl_nodes uses boost_python
+			else()
+				find_package(Boost 1.34 COMPONENTS filesystem regex system thread)
+			endif()
 			mark_as_advanced(Boost_DIR)  # why doesnt boost do this?
 		endif()
 
 			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}
+				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})
+				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_python3-${BOOST_POSTFIX}
+						debug libboost_python3-${BOOST_DEBUG_POSTFIX})
+				endif(WITH_CYCLES_OSL)
+				
 			set(BOOST_DEFINITIONS "-DBOOST_ALL_NO_LIB")
 		endif()
 			
 			set(OPENCOLORIO ${LIBDIR}/opencolorio)
 			set(OPENCOLORIO_INCLUDE_DIRS ${OPENCOLORIO}/include)
 			set(OPENCOLORIO_LIBRARIES OpenColorIO)
-			set_lib_path(OPENCOLORIO_LIBPATH "opencolorio/lib")
+			set(OPENCOLORIO_LIBPATH ${LIBDIR}/opencolorio/lib)
 			set(OPENCOLORIO_DEFINITIONS)
 		endif()
 
 			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}
+				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})
+				boost_regex-${BOOST_DEBUG_POSTFIX}
+				boost_system-${BOOST_DEBUG_POSTFIX} boost_thread-${BOOST_DEBUG_POSTFIX})
+				if(WITH_CYCLES_OSL)
+					set(BOOST_LIBRARIES ${BOOST_LIBRARIES}
+						optimized libboost_python3-${BOOST_POSTFIX}
+						debug libboost_python3-${BOOST_DEBUG_POSTFIX}) 
+				endif(WITH_CYCLES_OSL)
+					
 			set(BOOST_LIBPATH ${BOOST}/lib)
 			set(BOOST_DEFINITIONS "-DBOOST_ALL_NO_LIB -DBOOST_THREAD_USE_LIB ")
 		endif()
 		set(PLATFORM_LINKFLAGS "-Xlinker --stack=2097152")
 
 		## DISABLE - causes linking errors 
-		## for re-distrobution, so users dont need mingw installed
+		## for re-distribution, so users dont need mingw installed
 		# set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -static-libgcc -static-libstdc++")
 
 	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 Iex Half IlmImf Imath IlmThread)
 		set(OPENEXR_LIBPATH ${OPENEXR}/lib)
 	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)
+		if(WITH_CYCLES_OSL)
+			set(BOOST_LIBRARIES boost_date_time-mt boost_filesystem-mt boost_python3-mt boost_regex-mt boost_system-mt boost_thread-mt)
+		else(WITH_CYCLES_OSL)
+			set(BOOST_LIBRARIES boost_date_time-mt boost_filesystem-mt boost_regex-mt boost_system-mt boost_thread-mt)
+		endif(WITH_CYCLES_OSL)
 		set(BOOST_LIBPATH ${BOOST}/lib)
 		set(BOOST_DEFINITIONS)
 	endif()
 	if(WITH_OPENIMAGEIO)
 		set(OPENIMAGEIO ${LIBDIR}/openimageio)
 		set(OPENIMAGEIO_INCLUDE_DIRS ${OPENIMAGEIO}/include)
-		set(OPENIMAGEIO_LIBRARIES OpenImageIO ${PNG_LIBRARIES} ${JPEG_LIBRARIES} ${TIFF_LIBRARY} ${OPENEXR_LIBRARIES} ${ZLIB_LIBRARIES})
+		set(OPENIMAGEIO_LIBRARIES -force_load ${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")
 	endif()
 		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} ${OSL_LIB_EXEC} ${OSL_LIB_QUERY})
+		list(APPEND OSL_LIBRARIES ${OSL_LIB_COMP} -force_load ${OSL_LIB_EXEC} ${OSL_LIB_QUERY})
 		find_path(OSL_INCLUDES OSL/oslclosure.h PATHS ${CYCLES_OSL}/include)
 		find_program(OSL_COMPILER NAMES oslc PATHS ${CYCLES_OSL}/bin)
 	
 		endif()
 	
 		include_directories(${OSL_INCLUDES})
+		
+
+		# LLVM library setup, needed for osl 
+		
+		set(LLVM_DIRECTORY "${LIBDIR}/llvm")
+		set(LLVM_STATIC YES)
+		if (LLVM_DIRECTORY)
+			set (LLVM_CONFIG "${LLVM_DIRECTORY}/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_DIRECTORY
+					 OUTPUT_STRIP_TRAILING_WHITESPACE)
+		execute_process (COMMAND ${LLVM_CONFIG} --libdir
+						 OUTPUT_VARIABLE LLVM_LIB_DIR
+					 OUTPUT_STRIP_TRAILING_WHITESPACE)
+		execute_process (COMMAND ${LLVM_CONFIG} --includedir
+						 OUTPUT_VARIABLE LLVM_INCLUDES
+					 OUTPUT_STRIP_TRAILING_WHITESPACE)
+		find_library ( LLVM_LIBRARY
+					   NAMES libLLVMAnalysis.a # first of a whole bunch of libs to get
+					   PATHS ${LLVM_LIB_DIR})
+		message (STATUS "LLVM version  = ${LLVM_VERSION}")
+		message (STATUS "LLVM dir      = ${LLVM_DIRECTORY}")
+		message (STATUS "LLVM includes = ${LLVM_INCLUDES}")
+		message (STATUS "LLVM lib dir  = ${LLVM_LIB_DIR}")
+
+		if (LLVM_LIBRARY AND LLVM_INCLUDES AND LLVM_DIRECTORY AND LLVM_LIB_DIR)
+		  # ensure include directory is added (in case of non-standard locations
+		  include_directories (BEFORE "${LLVM_INCLUDES}")
+		  string (REGEX REPLACE "\\." "" OSL_LLVM_VERSION ${LLVM_VERSION})
+		  message (STATUS "LLVM OSL_LLVM_VERSION = ${OSL_LLVM_VERSION}")
+		  add_definitions ("-DOSL_LLVM_VERSION=${OSL_LLVM_VERSION}")
+		  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.
+			set (LLVM_LIBRARY "")
+			execute_process (COMMAND ${LLVM_CONFIG} --libs
+						 OUTPUT_VARIABLE llvm_library_list
+					 OUTPUT_STRIP_TRAILING_WHITESPACE)
+			string (REPLACE "-l" "" llvm_library_list ${llvm_library_list})
+			string (REPLACE " " ";" llvm_library_list ${llvm_library_list})
+			foreach (f ${llvm_library_list})
+			  list (APPEND LLVM_LIBRARY "${LLVM_LIB_DIR}/lib${f}.a")
+			endforeach ()
+		  endif ()
+		  string (REPLACE ";" " " LLVM_LIBRARY "${LLVM_LIBRARY}")
+		  message (STATUS "LLVM library  = ${LLVM_LIBRARY}")
+		else ()
+		  message (FATAL_ERROR "LLVM not found.")
+		endif ()
+		set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} ${LLVM_LIBRARY}")
+		
+		# end LLVM library setup
+
 	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 "i386")
-		set(CMAKE_CXX_FLAGS_RELEASE "-O2 -mdynamic-no-pic -ftree-vectorize -msse -msse2 -fvariable-expansion-in-unroller")
-		set(CMAKE_C_FLAGS_RELEASE "-O2 -mdynamic-no-pic -ftree-vectorize -msse -msse2 -fvariable-expansion-in-unroller")
-	elseif(CMAKE_OSX_ARCHITECTURES MATCHES "x86_64")
-		set(CMAKE_CXX_FLAGS_RELEASE "-O2 -mdynamic-no-pic -ftree-vectorize -msse -msse2 -msse3 -mssse3 -fvariable-expansion-in-unroller")
-		set(CMAKE_C_FLAGS_RELEASE "-O2 -mdynamic-no-pic -ftree-vectorize -msse -msse2 -msse3 -mssse3 -fvariable-expansion-in-unroller")
+	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_CXX_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")
 	ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_MISSING_INCLUDE_DIRS -Wmissing-include-dirs)
 	ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_NO_DIV_BY_ZERO -Wno-div-by-zero)
 
-	# # this causes too many warnings, disable
-	# ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_UNDEFINED -Wundef)
-
 	# disable because it gives warnings for printf() & friends.
 	# ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_DOUBLE_PROMOTION -Wdouble-promotion -Wno-error=double-promotion)
 
 	ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_ALL -Wall)
 	ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_NO_INVALID_OFFSETOF -Wno-invalid-offsetof)
 	ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_NO_SIGN_COMPARE -Wno-sign-compare)
-	ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_MISSING_DECLARATIONS -Wmissing-declarations)
 	ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_LOGICAL_OP -Wlogical-op)
-	ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_UNDEF -Wundef)
 	ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_UNINITIALIZED -Wuninitialized)
 	ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_INIT_SELF -Winit-self)  # needs -Wuninitialized
 	ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_MISSING_INCLUDE_DIRS -Wmissing-include-dirs)
 	ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_NO_DIV_BY_ZERO -Wno-div-by-zero)
-	ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_UNDEFINED -Wundef)
+
+	# causes too many warnings
+	if(NOT APPLE)
+		ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_UNDEF -Wundef)
+		ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_MISSING_DECLARATIONS -Wmissing-declarations)
+	endif()
 
 	# flags to undo strict flags
 	ADD_CHECK_C_COMPILER_FLAG(CC_REMOVE_STRICT_FLAGS C_WARN_NO_DEPRECATED_DECLARATIONS -Wno-deprecated-declarations)

File blender/build_files/scons/config/win32-mingw-config.py

 PLATFORM_LINKFLAGS = ['-Xlinker', '--stack=2097152']
 
 ## DISABLED, causes linking errors!
-## for re-distrobution, so users dont need mingw installed
+## for re-distribution, so users dont need mingw installed
 # PLATFORM_LINKFLAGS += ["-static-libgcc", "-static-libstdc++"]
 
 BF_DEBUG = False

File blender/build_files/scons/config/win64-mingw-config.py

 PLATFORM_LINKFLAGS = ['-Xlinker', '--stack=2097152']
 
 ## DISABLED, causes linking errors!
-## for re-distrobution, so users dont need mingw installed
+## for re-distribution, so users dont need mingw installed
 # PLATFORM_LINKFLAGS += ["-static-libgcc", "-static-libstdc++"]
 
 BF_DEBUG = False

File blender/doc/python_api/rst/bge.logic.rst

 Game Logic (bge.logic)
 ======================
 
-*****
-Intro
-*****
+************
+Introduction
+************
 
 Module to access logic functions, imported automatically into the python controllers namespace.
 

File blender/doc/python_api/rst/bge.types.rst

 
 .. module:: bge.types
 
+************
+Introduction
+************
+
+This module contains the classes that appear as instances in the Game Engine. A
+script must interact with these classes if it is to affect the behaviour of
+objects in a game.
+
+The following example would move an object (i.e. an instance of
+:class:`KX_GameObject`) one unit up.
+
+.. code-block:: python
+
+   # bge.types.SCA_PythonController
+   cont = bge.logic.getCurrentController()
+
+   # bge.types.KX_GameObject
+   obj = cont.owner
+   obj.worldPosition.z += 1
+
+To run the code, it could be placed in a Blender text block and executed with
+a :class:`SCA_PythonController` logic brick.
+
+*****
+Types
+*****
+
 .. class:: PyObjectPlus
 
    PyObjectPlus base class of most other types in the Game Engine.
       
       Calling ANY method or attribute on an object that has been removed from a scene will raise a SystemError, if an object may have been removed since last accessing it use the :data:`invalid` attribute to check.
 
+   KX_GameObject can be subclassed to extend functionality. For example:
+
+   .. code-block:: python
+
+        import bge
+
+        class CustomGameObject(bge.types.KX_GameObject):
+            RATE = 0.05
+
+            def __init__(self, old_owner):
+                # "old_owner" can just be ignored. At this point, "self" is
+                # already the object in the scene, and "old_owner" has been
+                # destroyed.
+
+                # New attributes can be defined - but we could also use a game
+                # property, like "self['rate']".
+                self.rate = CustomGameObject.RATE
+
+            def update(self):
+                self.worldPosition.z += self.rate
+
+                # switch direction
+                if self.worldPosition.z > 1.0:
+                    self.rate = -CustomGameObject.RATE
+                elif self.worldPosition.z < 0.0:
+                    self.rate = CustomGameObject.RATE
+
+        # Called first
+        def mutate(cont):
+            old_object = cont.owner
+            mutated_object = CustomGameObject(cont.owner)
+
+            # After calling the constructor above, references to the old object
+            # should not be used.
+            assert(old_object is not mutated_object)
+            assert(old_object.invalid)
+            assert(mutated_object is cont.owner)
+
+        # Called later - note we are now working with the mutated object.
+        def update(cont):
+            cont.owner.update()
+
+   When subclassing objects other than empties and meshes, the specific type
+   should be used - e.g. inherit from :class:`BL_ArmatureObject` when the object
+   to mutate is an armature.
+
    .. attribute:: name
 
       The object's name. (read-only).

File blender/extern/carve/CMakeLists.txt

 		-DCARVE_SYSTEM_BOOST
 	)
 
-	list(APPEND INC
+	list(APPEND INC_SYS
 		${BOOST_INCLUDE_DIR}
 	)
 endif()

File blender/intern/audaspace/fftw/AUD_BandPassFactory.h

 	 * Sets the highest passed frequency.
 	 * \param high The highest passed frequency.
 	 */
-	void setHigh(float hight);
+	void setHigh(float high);
 
 	virtual AUD_IReader* createReader();
 };

File blender/intern/audaspace/intern/AUD_PyInit.h

 #endif
 
 /**
- * Initalizes the Python module.
+ * Initializes the Python module.
  */
 extern PyObject *AUD_initPython(void);
 

File blender/intern/bsp/CMakeLists.txt

 		-DCARVE_SYSTEM_BOOST
 	)
 
-	list(APPEND INC
+	list(APPEND INC_SYS
 		${BOOST_INCLUDE_DIR}
 	)
 endif()

File blender/intern/cycles/CMakeLists.txt

 	SYSTEM
 	${BOOST_INCLUDE_DIR}
 	${OPENIMAGEIO_INCLUDE_DIRS}
-	${OPENIMAGEIO_INCLUDE_DIRS}/OpenImageIO)
+	${OPENIMAGEIO_INCLUDE_DIRS}/OpenImageIO
+	${OPENEXR_INCLUDE_DIR})
 
 # Subdirectories
 

File blender/intern/cycles/blender/addon/ui.py

 
         col = split.column()
         sub = col.column()
-        sub.enabled = (device_type == 'NONE' or cscene.device == 'CPU')
+        sub.active = (device_type == 'NONE' or cscene.device == 'CPU')
         sub.prop(cscene, "progressive")
 
         sub = col.column(align=True)
         layout.prop(cdata, "dicing_rate")
 
 
+class Cycles_PT_mesh_normals(CyclesButtonsPanel, Panel):
+    bl_label = "Normals"
+    bl_context = "data"
+
+    @classmethod
+    def poll(cls, context):
+        return CyclesButtonsPanel.poll(context) and context.mesh
+
+    def draw(self, context):
+        layout = self.layout
+
+        mesh = context.mesh
+
+        split = layout.split()
+
+        col = split.column()
+        col.prop(mesh, "show_double_sided")
+
+        col = split.column()
+        col.label()
+
+
 class CyclesObject_PT_ray_visibility(CyclesButtonsPanel, Panel):
     bl_label = "Ray Visibility"
     bl_context = "object"
             layout.prop(cscene, "device")
         elif device_type == 'OPENCL' and cscene.feature_set == 'EXPERIMENTAL':
             layout.prop(cscene, "device")
-            
+
         if cscene.feature_set == 'EXPERIMENTAL' and cscene.device == 'CPU' and engine.with_osl():
             layout.prop(cscene, "shading_system")
 

File blender/intern/cycles/blender/blender_camera.cpp

 	return fabsf(transform_get_column(&mat, 3).z);
 }
 
-static void blender_camera_from_object(BlenderCamera *bcam, BL::Object b_ob)
+static void blender_camera_from_object(BlenderCamera *bcam, BL::Object b_ob, bool skip_panorama = false)
 {
 	BL::ID b_ob_data = b_ob.data();
 
 				bcam->type = CAMERA_ORTHOGRAPHIC;
 				break;
 			case BL::Camera::type_PANO:
-				bcam->type = CAMERA_PANORAMA;
+				if(!skip_panorama)
+					bcam->type = CAMERA_PANORAMA;
+				else
+					bcam->type = CAMERA_PERSPECTIVE;
 				break;
 			case BL::Camera::type_PERSP:
 			default:
 
 /* Sync 3D View Camera */
 
-static void blender_camera_from_view(BlenderCamera *bcam, BL::Scene b_scene, BL::SpaceView3D b_v3d, BL::RegionView3D b_rv3d, int width, int height)
+static void blender_camera_from_view(BlenderCamera *bcam, BL::Scene b_scene, BL::SpaceView3D b_v3d, BL::RegionView3D b_rv3d, int width, int height, bool skip_panorama = false)
 {
 	/* 3d view parameters */
 	bcam->nearclip = b_v3d.clip_start();
 		BL::Object b_ob = (b_v3d.lock_camera_and_layers())? b_scene.camera(): b_v3d.camera();
 
 		if(b_ob) {
-			blender_camera_from_object(bcam, b_ob);
+			blender_camera_from_object(bcam, b_ob, skip_panorama);
 
 			/* magic zoom formula */
 			bcam->zoom = (float)b_rv3d.view_camera_zoom();
 	/* get viewport viewplane */
 	BlenderCamera view_bcam;
 	blender_camera_init(&view_bcam);
-	blender_camera_from_view(&view_bcam, b_scene, b_v3d, b_rv3d, width, height);
+	blender_camera_from_view(&view_bcam, b_scene, b_v3d, b_rv3d, width, height, true);
 
 	blender_camera_viewplane(&view_bcam, width, height,
 		&view_left, &view_right, &view_bottom, &view_top, &view_aspect, &sensor_size);
 	/* get camera viewplane */
 	BlenderCamera cam_bcam;
 	blender_camera_init(&cam_bcam);
-	blender_camera_from_object(&cam_bcam, b_ob);
+	blender_camera_from_object(&cam_bcam, b_ob, true);
 
 	width = (int)(r.resolution_x()*r.resolution_percentage()/100);
 	height = (int)(r.resolution_y()*r.resolution_percentage()/100);

File blender/intern/cycles/blender/blender_object.cpp

 			hide = hide || !(ob_layer & scene_layer);
 
 			if(!hide) {
-				progress.set_status("Synchronizing object", (*b_ob).name());
+				progress.set_sync_status("Synchronizing object", (*b_ob).name());
 
 				int num_particles = object_count_particles(*b_ob);
 
 		}
 	}
 
+	progress.set_sync_status("");
+
 	if(!cancel && !motion) {
 		sync_background_light();
 

File blender/intern/cycles/blender/blender_util.h

 ID *rna_Object_to_mesh(void *_self, void *reports, void *scene, int apply_modifiers, int settings);
 void rna_Main_meshes_remove(void *bmain, void *reports, void *mesh);
 void rna_Object_create_duplilist(void *ob, void *reports, void *sce);
-void rna_Object_free_duplilist(void *ob, void *reports);
+void rna_Object_free_duplilist(void *ob);
 void rna_RenderLayer_rect_set(PointerRNA *ptr, const float *values);
 void rna_RenderPass_rect_set(PointerRNA *ptr, const float *values);
 struct RenderResult *RE_engine_begin_result(struct RenderEngine *engine, int x, int y, int w, int h, const char *layername);
 
 static inline void object_free_duplilist(BL::Object self)
 {
-	rna_Object_free_duplilist(self.ptr.data, NULL);
+	rna_Object_free_duplilist(self.ptr.data);
 }
 
 static inline bool BKE_object_is_modified(BL::Object self, BL::Scene scene, bool preview)

File blender/intern/cycles/kernel/kernel_passes.h

 		kernel_write_pass_float3(buffer + kernel_data.film.pass_glossy_color, sample, L->color_glossy);
 	if(flag & PASS_TRANSMISSION_COLOR)
 		kernel_write_pass_float3(buffer + kernel_data.film.pass_transmission_color, sample, L->color_transmission);
-	if(flag & PASS_SHADOW)
-		kernel_write_pass_float4(buffer + kernel_data.film.pass_shadow, sample, L->shadow);
+	if(flag & PASS_SHADOW) {
+		float4 shadow = L->shadow;
+
+		/* bit of an ugly hack to compensate for emitting triangles influencing
+		 * amount of samples we get for this pass */
+		if(kernel_data.integrator.progressive && kernel_data.integrator.pdf_triangles != 0.0f)
+			shadow.w = 0.5f;
+		else
+			shadow.w = 1.0f;
+
+		kernel_write_pass_float4(buffer + kernel_data.film.pass_shadow, sample, shadow);
+	}
 #endif
 }
 

File blender/intern/cycles/render/CMakeLists.txt

 	../kernel/osl
 	../bvh
 	../util
-	${GLEW_INCLUDE_PATH}
 )
 set(INC_SYS
 	${GLEW_INCLUDE_PATH}

File blender/intern/cycles/render/buffers.cpp

 		else if(components == 3) {
 			assert(pass.components == 4);
 
-			if(pass.divide_type != PASS_NONE) {
+			/* RGBA */
+			if(type == PASS_SHADOW) {
+				for(int i = 0; i < size; i++, in += pass_stride, pixels += 3) {
+					float4 f = make_float4(in[0], in[1], in[2], in[3]);
+					float invw = (f.w > 0.0f)? 1.0f/f.w: 1.0f;
+
+					pixels[0] = f.x*invw;
+					pixels[1] = f.y*invw;
+					pixels[2] = f.z*invw;
+				}
+			}
+			else if(pass.divide_type != PASS_NONE) {
 				/* RGB lighting passes that need to divide out color */
 				pass_offset = 0;
 				foreach(Pass& color_pass, params.passes) {

File blender/intern/cycles/render/image.cpp

 
 		device_vector<float4>& tex_img = dscene->tex_float_image[slot];
 
-		if(tex_img.device_pointer)
+		if(tex_img.device_pointer) {
+			thread_scoped_lock device_lock(device_mutex);
 			device->tex_free(tex_img);
+		}
 
 		if(!file_load_float_image(img, tex_img)) {
 			/* on failure to load, we set a 1x1 pixels pink image */
 		if(slot >= 10) name = string_printf("__tex_image_float_0%d", slot);
 		else name = string_printf("__tex_image_float_00%d", slot);
 
-		if(!pack_images)
+		if(!pack_images) {
+			thread_scoped_lock device_lock(device_mutex);
 			device->tex_alloc(name.c_str(), tex_img, true, true);
+		}
 	}
 	else {
 		string filename = path_filename(images[slot - tex_image_byte_start]->filename);
 
 		device_vector<uchar4>& tex_img = dscene->tex_image[slot - tex_image_byte_start];
 
-		if(tex_img.device_pointer)
+		if(tex_img.device_pointer) {
+			thread_scoped_lock device_lock(device_mutex);
 			device->tex_free(tex_img);
+		}
 
 		if(!file_load_image(img, tex_img)) {
 			/* on failure to load, we set a 1x1 pixels pink image */
 		if(slot >= 10) name = string_printf("__tex_image_0%d", slot);
 		else name = string_printf("__tex_image_00%d", slot);
 
-		if(!pack_images)
+		if(!pack_images) {
+			thread_scoped_lock device_lock(device_mutex);
 			device->tex_alloc(name.c_str(), tex_img, true, true);
+		}
 	}
 
 	img->need_load = false;
 #endif
 		}
 		else if(is_float) {
-			device->tex_free(dscene->tex_float_image[slot]);
-			dscene->tex_float_image[slot].clear();
+			device_vector<float4>& tex_img = dscene->tex_float_image[slot];
+
+			if(tex_img.device_pointer) {
+				thread_scoped_lock device_lock(device_mutex);
+				device->tex_free(tex_img);
+			}
+
+			tex_img.clear();
 
 			delete float_images[slot];
 			float_images[slot] = NULL;
 		}
 		else {
-			device->tex_free(dscene->tex_image[slot - tex_image_byte_start]);
-			dscene->tex_image[slot - tex_image_byte_start].clear();
+			device_vector<uchar4>& tex_img = dscene->tex_image[slot - tex_image_byte_start];
+
+			if(tex_img.device_pointer) {
+				thread_scoped_lock device_lock(device_mutex);
+				device->tex_free(tex_img);
+			}
+
+			tex_img.clear();
 
 			delete images[slot - tex_image_byte_start];
 			images[slot - tex_image_byte_start] = NULL;
 {
 	if(!need_update)
 		return;
-	
+
 	TaskPool pool;
 
 	for(size_t slot = 0; slot < images.size(); slot++) {
 		device_free_image(device, dscene, slot);
 
 	device->tex_free(dscene->tex_image_packed);
-	dscene->tex_image_packed.clear();
-
 	device->tex_free(dscene->tex_image_packed_info);
+
+	dscene->tex_image_packed.clear();
 	dscene->tex_image_packed_info.clear();
 
 	images.clear();

File blender/intern/cycles/render/image.h

 #include "device_memory.h"
 
 #include "util_string.h"
+#include "util_thread.h"
 #include "util_vector.h"
 
 CCL_NAMESPACE_BEGIN
 	int tex_num_images;
 	int tex_num_float_images;
 	int tex_image_byte_start;
+	thread_mutex device_mutex;
 
 	struct Image {
 		string filename;

File blender/intern/cycles/render/light.cpp

 	main_task.shader_x = 0;
 	main_task.shader_w = width*height;
 
+	/* disabled splitting for now, there's an issue with multi-GPU mem_copy_from */
+#if 0
 	list<DeviceTask> split_tasks;
-	main_task.split_max_size(split_tasks, 128*128);
+	main_task.split_max_size(split_tasks, 128*128); 
 
 	foreach(DeviceTask& task, split_tasks) {
 		device->task_add(task);
 		device->task_wait();
 	}
+#else
+	device->task_add(main_task);
+	device->task_wait();
+#endif
 
 	device->mem_copy_from(d_output, 0, 1, d_output.size(), sizeof(float4));
 	device->mem_free(d_input);

File blender/intern/cycles/util/util_progress.h

 		tile_time = 0.0f;
 		status = "Initializing";
 		substatus = "";
+		sync_status = "";
+		sync_substatus = "";
 		update_cb = NULL;
 		cancel = false;
 		cancel_message = "";
 		set_update();
 	}
 
+	void set_sync_status(const string& status_, const string& substatus_ = "")
+	{
+		{
+			thread_scoped_lock lock(progress_mutex);
+			sync_status = status_;
+			sync_substatus = substatus_;
+			total_time = time_dt() - start_time;
+		}
+
+		set_update();
+
+	}
+
+	void set_sync_substatus(const string& substatus_)
+	{
+		{
+			thread_scoped_lock lock(progress_mutex);
+			sync_substatus = substatus_;
+			total_time = time_dt() - start_time;
+		}
+
+		set_update();
+	}
+
 	void get_status(string& status_, string& substatus_)
 	{
 		thread_scoped_lock lock(progress_mutex);
-		status_ = status;
-		substatus_ = substatus;
+
+		if(sync_status != "") {
+			status_ = sync_status;
+			substatus_ = sync_substatus;
+		}
+		else {
+			status_ = status;
+			substatus_ = substatus;
+		}
 	}
 
 	/* callback */
 	string status;
 	string substatus;
 
+	string sync_status;
+	string sync_substatus;
+
 	volatile bool cancel;
 	string cancel_message;
 };

File blender/intern/opencolorio/CMakeLists.txt

 #
 # ***** END GPL LICENSE BLOCK *****
 
+set(INC
+	.
+	../guardedalloc
+)
+
+set(INC_SYS
+)
+
+
 if(WITH_OPENCOLORIO)
-	set(INC
-		.
-		${OPENCOLORIO_INCLUDE_DIRS}
-	)
 
-	set(SRC
-		ocio_capi.cpp
-		ocio_capi.h
+	list(APPEND INC_SYS
+		${OPENCOLORIO_INCLUDE_DIRS}
 	)
 
 	if(WIN32 AND NOT MINGW)
-		list(APPEND INC
+		list(APPEND INC_SYS
 			${BOOST_INCLUDE_DIR}
 		)
 	endif()
+
+	set(SRC
+		ocio_capi.cpp
+		ocio_capi.h
+	)
 else()
-	set(INC
-		.
+	list(APPEND INC
 		../../source/blender/blenlib
 	)
 
 	)
 endif()
 
-set(INC_SYS
-	../guardedalloc
-)
-
 add_definitions(
 )
 

File blender/intern/opencolorio/ocio_capi.cpp

 #define OCIO_CAPI_IMPLEMENTATION
 #include "ocio_capi.h"
 
-#ifdef NDEBUG
+#if !defined(WITH_ASSERT_ABORT)
 #  define OCIO_abort()
 #else
 #  include <stdlib.h>
 {
 	std::cerr << "OpenColorIO Error: " << err << std::endl;
 
-	// OCIO_abort();
+	OCIO_abort();
 }
 
 static void OCIO_reportException(Exception &exception)

File blender/intern/tools/bpy_introspect_ui.py

     def __sub__(self, other):
         return self
 
+    def __truediv__(self, other):
+        return self
+
+    def __floordiv__(self, other):
+        return self
+
+    def __round__(self, other):
+        return self
+
+    def __float__(self):
+        return 0.0
+
     # Custom functions
     def lower(self):
         return ""
 def fake_main():
     bpy = module_add("bpy")
 
+    # Registerable Subclasses
     bpy.types = module_add("bpy.types")
     bpy.types.Panel = Panel
     bpy.types.Header = Header
     bpy.types.PropertyGroup = PropertyGroup
     bpy.types.Operator = Operator
 
+    # ID Subclasses
     bpy.types.Armature = type("Armature", (), {})
     bpy.types.Bone = type("Bone", (), {})
     bpy.types.EditBone = type("EditBone", (), {})
     bpy.types.Mesh = type("Mesh", (), {})
     bpy.types.MetaBall = type("MetaBall", (), {})
     bpy.types.Object = type("Object", (), {})
+    bpy.types.Speaker = type("Speaker", (), {})
     bpy.types.Texture = type("Texture", (), {})
     bpy.types.ParticleSettings = type("ParticleSettings", (), {})
     bpy.types.World = type("World", (), {})
     bpy.props.IntProperty = dict
     bpy.props.EnumProperty = dict
 
+
+def fake_helper():
+
+    class PropertyPanel():
+        pass
+
+    rna_prop_ui = module_add("rna_prop_ui")
+    rna_prop_ui.PropertyPanel = PropertyPanel
+    rna_prop_ui.draw = NewAttr("rna_prop_ui.draw", "draw")
+
+    rigify = module_add("rigify")
+    rigify.get_submodule_types = lambda: []
+
+
+def fake_runtime():
+    """Only call this before `draw()` functions."""
+
+    # Misc Subclasses
+    bpy.types.EffectSequence = type("EffectSequence", (), {})
+
+    # Operator Subclases
+    bpy.types.WM_OT_doc_view = type("WM_OT_doc_view", (), {"_prefix": ""})
+
     bpy.data = module_add("bpy.data")
     bpy.data.scenes = ()
+    bpy.data.speakers = ()
     bpy.data.groups = ()
     bpy.data.meshes = ()
     bpy.data.shape_keys = ()
     bpy.data.materials = ()
+    bpy.data.lattices = ()
     bpy.data.lamps = ()
     bpy.data.textures = ()
     bpy.data.cameras = ()
     bpy.data.curves = ()
+    bpy.data.masks = ()
     bpy.data.metaballs = ()
+    bpy.data.movieclips = ()
     bpy.data.armatures = ()
     bpy.data.particles = ()
 
     bpy.data.file_is_saved = True
-
+    
     bpy.utils = module_add("bpy.utils")
     bpy.utils.smpte_from_frame = lambda f: ""
     bpy.utils.script_paths = lambda f: []
     bpy.path = module_add("bpy.path")
     bpy.path.display_name = lambda f: ""
 
+    bpy_extras = module_add("bpy_extras")
+    bpy_extras.keyconfig_utils = module_add("bpy_extras.keyconfig_utils")
+    bpy_extras.keyconfig_utils.KM_HIERARCHY = ()
+    bpy_extras.keyconfig_utils.keyconfig_merge = lambda a, b: ()
 
-def fake_helper():
-
-    class PropertyPanel():
-        pass
-
-    rna_prop_ui = module_add("rna_prop_ui")
-    rna_prop_ui.PropertyPanel = PropertyPanel
-    rna_prop_ui.draw = NewAttr("rna_prop_ui.draw", "draw")
-
-    rigify = module_add("rigify")
-    rigify.get_submodule_types = lambda: []
-
+    addon_utils = module_add("addon_utils")
+    addon_utils.modules = lambda f: ()
+    addon_utils.module_bl_info = lambda f: None
+    addon_utils.addons_fake_modules = {}
+    addon_utils.error_duplicates = ()
+    addon_utils.error_encoding = ()
 
 fake_main()
 fake_helper()
+# fake_runtime()  # call after initial import so we can catch
+#                 # bad use of modules outside of draw() functions.
 
 import bpy
 
-sys.path.insert(0, "/b/release/scripts/ui/")
-
 
 def module_classes(mod):
     classes = []
-    for value in mod.__dict__.values():
+    for key, value in mod.__dict__.items():
         try:
             is_subclass = issubclass(value, BaseFakeUI)
         except:
 
 
 def main():
+
     import os
+    BASE_DIR = os.path.join(os.path.dirname(__file__), "..", "..")
+    BASE_DIR = os.path.normpath(os.path.abspath(BASE_DIR))
+    MODULE_DIR = os.path.join(BASE_DIR, "release", "scripts", "startup")
+
+    print("Using base dir: %r" % BASE_DIR)
+    print("Using module dir: %r" % MODULE_DIR)
 
-    base = os.path.join(os.path.dirname(__file__), "..", "..")
-    base = os.path.normpath(base)
-    base = os.path.abspath(base)
+    sys.path.insert(0, MODULE_DIR)
 
-    scripts_dir = os.path.join(base, "release", "scripts", "ui")
+    scripts_dir = os.path.join(MODULE_DIR, "bl_ui")
     for f in sorted(os.listdir(scripts_dir)):
-        if f.endswith(".py"):
+        if f.endswith(".py") and not f.startswith("__init__"):
             # print(f)
-            mod = __import__(f[:-3])
+            mod = __import__("bl_ui." + f[:-3]).__dict__[f[:-3]]
 
             classes = module_classes(mod)
 
             for cls in classes:
                 setattr(bpy.types, cls.__name__, cls)
 
+
+    fake_runtime()
+
     # print("running...")
     print("<ui>")
     for f in sorted(os.listdir(scripts_dir)):
-        if f.endswith(".py"):
+        if f.endswith(".py") and not f.startswith("__init__"):
             # print(f)
-            mod = __import__(f[:-3])
+            mod = __import__("bl_ui." + f[:-3]).__dict__[f[:-3]]
 
             classes = module_classes(mod)
 

File blender/release/datafiles/colormanagement/config.ocio

 description: RRT version ut33
 
 roles:
-  reference: Linear ACES
+  reference: Linear
 
   # Internal scene linear space
   scene_linear: Linear
     - !<View> {name: Raw, colorspace: Raw}
     - !<View> {name: Log, colorspace: adx10}
   None:
-    - !<View> {name: Default, colorspace: raw}
+    - !<View> {name: Default, colorspace: Raw}
 
 active_displays: [sRGB, DCIP3, Rec709, XYZ, None]
 active_views: [Default, RRT, Raw, Log]
 
 colorspaces:
   - !<ColorSpace>
-    name: Linear ACES
+    name: Linear
     family: aces
     equalitygroup:
     bitdepth: 32f
+    description: |
+      Rec. 709 (Full Range), Blender native linear space
     isdata: false
     allocation: lg2
     allocationvars: [-8.5, 5]
         - !<FileTransform> {src: adx_cid_to_rle.spi1d, interpolation: linear}
         - !<LogTransform> {base: 10, direction: inverse}
         - !<FileTransform> {src: adx_exp_to_aces.spimtx}
+        - !<FileTransform> {src: rec709_to_aces.spimtx, interpolation: linear, direction: inverse}
 
   - !<ColorSpace>
-    name: Linear
+    name: Linear ACES
     family:
     equalitygroup:
     bitdepth: 32f
     description: |
-      Rec. 709 (Full Range), Blender native linear space
+      ACES linear space
     isdata: false
     allocation: uniform
-    allocationvars: [-0.125, 1.125]
-    to_reference: !<FileTransform> {src: rec709_to_aces.spimtx, interpolation: nearest}
+    allocationvars: [-8.5, 5]
+    to_reference: !<FileTransform> {src: rec709_to_aces.spimtx, interpolation: linear, direction: inverse}
 
   - !<ColorSpace>
     name: rrt_srgb
     allocationvars: [0, 1]
     from_reference: !<GroupTransform>
       children:
+        - !<FileTransform> {src: rec709_to_aces.spimtx, interpolation: nearest}
         - !<AllocationTransform> {allocation: lg2, vars: [-8.5, 5]}
         - !<FileTransform> {src: rrt_ut33_sRGB.spi3d, interpolation: tetrahedral}
 
     to_reference: !<GroupTransform>
       children:
         - !<FileTransform> {src: rec709.spi1d, interpolation: linear}
-        - !<FileTransform> {src: rec709_to_aces.spimtx, interpolation: nearest}
 
   - !<ColorSpace>
     name: rrt_rec709
     allocationvars: [0, 1]
     from_reference: !<GroupTransform>
       children:
+        - !<FileTransform> {src: rec709_to_aces.spimtx, interpolation: nearest}
         - !<AllocationTransform> {allocation: lg2, vars: [-8.5, 5]}
         - !<FileTransform> {src: rrt_ut33_rec709.spi3d, interpolation: tetrahedral}
 
     allocationvars: [0, 1]
     from_reference: !<GroupTransform>
       children:
+        - !<FileTransform> {src: rec709_to_aces.spimtx, interpolation: nearest}
         - !<AllocationTransform> {allocation: lg2, vars: [-8.5, 5]}
         - !<FileTransform> {src: rrt_ut33_p3dci.spi3d, interpolation: tetrahedral}
 
     allocationvars: [0, 1]
     from_reference: !<GroupTransform>
       children:
+        - !<FileTransform> {src: rec709_to_aces.spimtx, interpolation: nearest}
         - !<FileTransform> {src: aces_to_xyz.spimtx, interpolation: linear}
 
   - !<ColorSpace>
     allocationvars: [0, 1]
     from_reference: !<GroupTransform>
       children:
+        - !<FileTransform> {src: rec709_to_aces.spimtx, interpolation: nearest}
         - !<AllocationTransform> {allocation: lg2, vars: [-8.5, 5]}
         - !<FileTransform> {src: rrt_ut33_dcdm.spi3d, interpolation: tetrahedral}
 
     allocationvars: [0, 1]
     from_reference: !<GroupTransform>
       children:
-        - !<FileTransform> {src: rec709_to_aces.spimtx, interpolation: linear, direction: inverse}
         - !<FileTransform> {src: srgb_to_xyz.spimtx, interpolation: linear}
         - !<FileTransform> {src: dci_xyz.spi1d, interpolation: linear}
 
     to_reference: !<GroupTransform>
       children:
         - !<FileTransform> {src: lg10.spi1d, interpolation: nearest}
-        - !<FileTransform> {src: rec709_to_aces.spimtx, interpolation: nearest}
 
   - !<ColorSpace>
     name: srgb8
     allocation: uniform
     from_reference: !<GroupTransform>
       children:
-        - !<ColorSpaceTransform> {src: Linear ACES, dst: lg10}
+        - !<ColorSpaceTransform> {src: Linear, dst: lg10}
         - !<FileTransform> {src: spi_ocio_srgb_test.spi3d, interpolation: linear}
 
   - !<ColorSpace>
     to_reference: !<GroupTransform>
       children:
         - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
-        - !<FileTransform> {src: rec709_to_aces.spimtx, interpolation: nearest}
 
   - !<ColorSpace>
     name: VD16
     to_reference: !<GroupTransform>
       children:
         - !<FileTransform> {src: vd16.spi1d, interpolation: nearest}
-        - !<FileTransform> {src: rec709_to_aces.spimtx, interpolation: linear}
 
   - !<ColorSpace>
     name: Non-Color
     allocation: uniform
     from_reference: !<GroupTransform>
       children:
-        - !<ColorSpaceTransform> {src: Linear ACES, dst: lg10}
+        - !<ColorSpaceTransform> {src: Linear, dst: lg10}
         - !<FileTransform> {src: colorworks_filmlg_to_p3.3dl, interpolation: linear}

File blender/release/datafiles/startup.blend

Binary file modified.

File blender/release/scripts/modules/addon_utils.py

     try:
         mod.register()
     except:
-        print("Exception in module register(): %r" % getattr(mod, "__file__", module_name))
+        print("Exception in module register(): %r" %
+              getattr(mod, "__file__", module_name))
         handle_error()
         del sys.modules[module_name]
         return None
         try:
             mod.unregister()
         except:
-            print("Exception in module unregister(): %r" % getattr(mod, "__file__", module_name))
+            print("Exception in module unregister(): %r" %
+                  getattr(mod, "__file__", module_name))
             import traceback
             traceback.print_exc()
     else:

File blender/release/scripts/modules/bl_i18n_utils/bl_process_msg.py

 #
 # ***** END GPL LICENSE BLOCK *****
 
-# <pep8-80 compliant>
+# <pep8 compliant>
 
 # Write out messages.txt from Blender.
 # XXX: This script is meant to be used from inside Blender!
 
 NC_ALLOWED = settings.WARN_MSGID_NOT_CAPITALIZED_ALLOWED
 
+
 def check(check_ctxt, messages, key, msgsrc):
     if check_ctxt is None:
         return
     import bpy
 
     def classBlackList():
-        blacklist_rna_class = [# core classes
+        blacklist_rna_class = [
+                               # core classes
                                "Context", "Event", "Function", "UILayout",
                                "BlendData",
                                # registerable classes

File blender/release/scripts/modules/bl_i18n_utils/check_po.py

               "    {} specific context{} present:\n            {}\n"
               "".format(glob_stats["nbr"], glob_stats["lvl"] / glob_stats["nbr"],
                         glob_stats["lvl_ttips"] / glob_stats["nbr"],
-                        glob_stats["lvl_trans_ttips"]/glob_stats["nbr"],
-                        glob_stats["lvl_ttips_in_trans"]/glob_stats["nbr"],
-                        glob_stats["lvl_comm"]/glob_stats["nbr"], glob_stats["nbr_signs"],
+                        glob_stats["lvl_trans_ttips"] / glob_stats["nbr"],
+                        glob_stats["lvl_ttips_in_trans"] / glob_stats["nbr"],
+                        glob_stats["lvl_comm"] / glob_stats["nbr"], glob_stats["nbr_signs"],
                         glob_stats["nbr_trans_signs"], nbr_contexts, _ctx_txt,
                         "\n            ".join(glob_stats["contexts"]-{""})))
 

File blender/release/scripts/modules/bl_i18n_utils/utils.py

         msgctxt_lines = []
         comment_lines = []
 
-
     def finalize_message():
         nonlocal reading_msgid, reading_msgstr, reading_msgctxt, \
                  reading_comment, is_fuzzy, is_translated, is_commented, \
         if reading_msgstr:
             finalize_message()
 
-
     return (messages,
             {"trans_msg": translated_messages,
              "fuzzy_msg": fuzzy_messages,

File blender/release/scripts/modules/bpy/utils.py

 
 _script_module_dirs = "startup", "modules"
 
+
 def _test_import(module_name, loaded_modules):
     use_time = _bpy.app.debug_python
 
 # hooks for doc lookups
 _manual_map = [_blender_default_map]
 
+
 def register_manual_map(manual_hook):
     _manual_map.append(manual_hook)
 
+
 def unregister_manual_map(manual_hook):
     _manual_map.remove(manual_hook)
 
+
 def manual_map():
     # reverse so default is called last
     for cb in reversed(_manual_map):
             continue
 
         yield prefix, url_manual_mapping
-

File blender/release/scripts/modules/console_python.py

     for line in sc.scrollback:
         text = line.body
         type = line.type
-        
+
         if type == 'INFO':  # ignore autocomp.
             continue
         if type == 'INPUT':

File blender/release/scripts/modules/rna_xml.py

                         try:
                             value_xml_coerce = [int(v) for v in value_xml_split]
                         except ValueError:
-                            value_xml_coerce = [float(v) for v in value_xml_split]
+                            try:
+                                value_xml_coerce = [float(v) for v in value_xml_split]
+                            except ValueError:  # bool vector property
+                                value_xml_coerce = [{'TRUE': True, 'FALSE': False}[v] for v in value_xml_split]
                         del value_xml_split
                     tp_name = 'ARRAY'
 

File blender/release/scripts/presets/interface_theme/back_to_black.xml

                    handle_auto="#909000"
                    handle_sel_auto="#f0ff40"
                    bone_pose="#50c8ff"
+                   bone_pose_active="#8cffff"
                    bone_solid="#c8c8c8"
                    bundle_solid="#c8c8c8"
                    camera="#000000"

File blender/release/scripts/presets/interface_theme/blender_24x.xml

                    handle_auto="#909000"
                    handle_sel_auto="#f0ff40"
                    bone_pose="#50c8ff"
+                   bone_pose_active="#8cffff"
                    bone_solid="#c8c8c8"
                    bundle_solid="#c8c8c8"
                    camera="#000000"

File blender/release/scripts/presets/interface_theme/elsyiun.xml

                    handle_auto="#909000"
                    handle_sel_auto="#f0ff40"
                    bone_pose="#50c8ff"
+                   bone_pose_active="#8cffff"
                    bone_solid="#c8c8c8"
                    bundle_solid="#c8c8c8"
                    camera="#000000"

File blender/release/scripts/presets/interface_theme/hexagon.xml

                    handle_auto="#909000"
                    handle_sel_auto="#f0ff40"
                    bone_pose="#50c8ff"
+                   bone_pose_active="#8cffff"
                    bone_solid="#c8c8c8"
                    bundle_solid="#c8c8c8"
                    camera="#000000"

File blender/release/scripts/presets/interface_theme/ubuntu_ambiance.xml

                    handle_auto="#909000"
                    handle_sel_auto="#f0ff40"
                    bone_pose="#50c8ff"
+                   bone_pose_active="#8cffff"
                    bone_solid="#c8c8c8"
                    bundle_solid="#c8c8c8"
                    camera="#000000"

File blender/release/scripts/presets/tracking_settings/blurry_footage.py

 settings.use_default_red_channel = True
 settings.use_default_green_channel = True
 settings.use_default_blue_channel = True
-settings.default_correlation_min = 0.6
+settings.default_correlation_min = 0.6

File blender/release/scripts/presets/tracking_settings/default.py

 settings.use_default_red_channel = True
 settings.use_default_green_channel = True
 settings.use_default_blue_channel = True
-settings.default_correlation_min = 0.75
+settings.default_correlation_min = 0.75

File blender/release/scripts/presets/tracking_settings/fast_motion.py

 settings.use_default_red_channel = True
 settings.use_default_green_channel = True
 settings.use_default_blue_channel = True
-settings.default_correlation_min = 0.6
+settings.default_correlation_min = 0.6

File blender/release/scripts/presets/tracking_settings/planar.py