Merged changes in the trunk up to revision 42021.

Conflicts resolved:
source/blender/blenkernel/intern/scene.c
source/blender/blenloader/intern/readfile.c
source/blender/editors/interface/resources.c
source/blender/render/intern/source/pipeline.c

37 files changed, 774 insertions, 153 deletions

diff --git a/intern/cycles/CMakeLists.txt b/intern/cycles/CMakeLists.txt
index d1ee5e0050d..a85b2ba8c2a 100644
--- a/intern/cycles/CMakeLists.txt
+++ b/intern/cycles/CMakeLists.txt
@@ -9,31 +9,18 @@ include(cmake/external_libs.cmake)
 # Build Flags
 
 if(WITH_RAYOPTIMIZATION AND SUPPORT_SSE_BUILD)
-	set(GCC_OPTIM_FLAGS "-ffast-math -msse -msse2 -msse3")
-endif()
-
-if(APPLE)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GCC_OPTIM_FLAGS}")
-	set(RTTI_DISABLE_FLAGS "-fno-rtti -DBOOST_NO_RTTI -DBOOST_NO_TYPEID")
-endif()
+	set(WITH_CYCLES_OPTIMIZED_KERNEL ON)
 
-if(WIN32)
-	if(MSVC)
-		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Ox /Ot /arch:SSE2 -D_CRT_SECURE_NO_WARNINGS /EHsc /fp:fast")
-		set(RTTI_DISABLE_FLAGS "/GR- -DBOOST_NO_RTTI -DBOOST_NO_TYPEID")
+	if(WIN32 AND MSVC)
+		set(CYCLES_OPTIMIZED_KERNEL_FLAGS "/Ox /Ot /arch:SSE2 -D_CRT_SECURE_NO_WARNINGS /EHsc /fp:fast")
 	elseif(CMAKE_COMPILER_IS_GNUCC)
-		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GCC_OPTIM_FLAGS}")
-		set(RTTI_DISABLE_FLAGS "-fno-rtti -DBOOST_NO_RTTI -DBOOST_NO_TYPEID")
+		set(CYCLES_OPTIMIZED_KERNEL_FLAGS "-ffast-math -msse -msse2 -msse3 -DGOGOGO")
 	endif()
 endif()
 
-if(UNIX AND NOT APPLE)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GCC_OPTIM_FLAGS}")
-	set(RTTI_DISABLE_FLAGS "-fno-rtti -DBOOST_NO_RTTI -DBOOST_NO_TYPEID")
-endif()
-
-# not needed yet, is for open shading language
-set(RTTI_DISABLE_FLAGS "")
+# for OSL, not needed yet
+# set(RTTI_DISABLE_FLAGS "-fno-rtti -DBOOST_NO_RTTI -DBOOST_NO_TYPEID")
+# set(RTTI_DISABLE_FLAGS "/GR- -DBOOST_NO_RTTI -DBOOST_NO_TYPEID")
 
 # Definitions and Includes
 
@@ -42,6 +29,10 @@ add_definitions(${BOOST_DEFINITIONS} ${OPENIMAGEIO_DEFINITIONS})
 add_definitions(-DCCL_NAMESPACE_BEGIN=namespace\ ccl\ {)
 add_definitions(-DCCL_NAMESPACE_END=})
 
+if(WITH_CYCLES_OPTIMIZED_KERNEL)
+	add_definitions(-DWITH_OPTIMIZED_KERNEL)
+endif()
+
 if(WITH_CYCLES_NETWORK)
   add_definitions(-DWITH_NETWORK)
 endif()
@@ -70,6 +61,7 @@ include_directories(
 # Subdirectories
 
 if(WITH_CYCLES_BLENDER)
+	add_definitions(-DBLENDER_PLUGIN)
 	add_subdirectory(blender)
 endif(WITH_CYCLES_BLENDER)
 
diff --git a/intern/cycles/SConscript b/intern/cycles/SConscript
index e2c81edea37..4d45a6875a9 100644
--- a/intern/cycles/SConscript
+++ b/intern/cycles/SConscript
@@ -6,15 +6,14 @@ cycles = env.Clone()
 
 cycles.Depends('../../source/blender/makesrna/intern/RNA_blender_cpp.h', 'makesrna')
 
-sources = cycles.Glob('bvh/*.cpp') + cycles.Glob('device/*.cpp') + cycles.Glob('kernel/*.cpp') + cycles.Glob('render/*.cpp') + cycles.Glob('subd/*.cpp') + cycles.Glob('util/*.cpp') + cycles.Glob('util/*.c') + cycles.Glob('blender/*.cpp')
+sources = cycles.Glob('bvh/*.cpp') + cycles.Glob('device/*.cpp') + cycles.Glob('kernel/*.cpp') + cycles.Glob('render/*.cpp') + cycles.Glob('subd/*.cpp') + cycles.Glob('util/*.cpp') + cycles.Glob('blender/*.cpp')
 
 sources.remove(path.join('util', 'util_view.cpp'))
 sources.remove(path.join('render', 'film_response.cpp'))
+sources.remove(path.join('kernel', 'kernel_optimized.cpp'))
 
 incs = [] 
 defs = []
-ccflags = []
-cxxflags = []
 
 defs.append('CCL_NAMESPACE_BEGIN=namespace ccl {')
 defs.append('CCL_NAMESPACE_END=}')
@@ -23,14 +22,6 @@ defs.append('WITH_OPENCL')
 defs.append('WITH_MULTI')
 defs.append('WITH_CUDA')
 
-if env['OURPLATFORM'] in ('win32-mingw'):
-    if env['WITH_BF_RAYOPTIMIZATION']:
-        cxxflags.append('-ffast-math -msse -msse2 -msse3'.split())
-        ccflags.append('-ffast-math -msse -msse2 -msse3'.split())
-    # not needed yet, is for open shading language
-    # cxxflags.append('-fno-rtti'.split())
-    # defs.append('BOOST_NO_RTTI BOOST_NO_TYPEID'.split())
-
 incs.extend('. bvh render device kernel kernel/osl kernel/svm util subd'.split())
 incs.extend('#intern/guardedalloc #source/blender/makesrna #source/blender/makesdna'.split())
 incs.extend('#source/blender/blenloader ../../source/blender/makesrna/intern'.split())
@@ -39,5 +30,20 @@ incs.append(cycles['BF_OIIO_INC'])
 incs.append(cycles['BF_BOOST_INC'])
 incs.append(cycles['BF_PYTHON_INC'])
 
-cycles.BlenderLib('bf_intern_cycles', sources, incs, defs, libtype=['intern'], priority=[0], compileflags=[None], cc_compileflags=ccflags, cxx_compileflags=cxxflags)
+# optimized kernel
+if env['WITH_BF_RAYOPTIMIZATION']:
+    optim_cxxflags = []
+
+    if env['OURPLATFORM'] in ('win32-vc', 'win64-vc'):
+        optim_cxxflags.append('/Ox /Ot /arch:SSE2 -D_CRT_SECURE_NO_WARNINGS /EHsc /fp:fast'.split())
+    else:
+        optim_cxxflags.append('-ffast-math -msse -msse2 -msse3'.split())
+    
+    optim_defs = defs + ['WITH_OPTIMIZED_KERNEL']
+    optim_sources = [path.join('kernel', 'kernel_optimized.cpp')]
+
+    cycles_optim = cycles.Clone()
+    cycles_optim.BlenderLib('bf_intern_cycles_optimized', optim_sources, incs, optim_defs, libtype=['intern'], priority=[0], compileflags=[None], cxx_compileflags=optim_cxxflags)
+
+cycles.BlenderLib('bf_intern_cycles', sources, incs, defs, libtype=['intern'], priority=[0], compileflags=[None])
 
diff --git a/intern/cycles/blender/CMakeLists.txt b/intern/cycles/blender/CMakeLists.txt
index f3da1a30eb2..e81f02f2090 100644
--- a/intern/cycles/blender/CMakeLists.txt
+++ b/intern/cycles/blender/CMakeLists.txt
@@ -6,15 +6,18 @@ set(INC
 	../kernel/svm
 	../util
 	../subd
+	../../../intern/guardedalloc
+	../../../source/blender/makesdna
+	../../../source/blender/makesrna
+	../../../source/blender/blenloader
+	${CMAKE_BINARY_DIR}/source/blender/makesrna/intern
 )
 
 set(INC_SYS
-	${BLENDER_INCLUDE_DIRS}
 	${PYTHON_INCLUDE_DIRS}
 	${GLEW_INCLUDE_PATH}
 )
 
-
 set(SRC
 	blender_camera.cpp
 	blender_mesh.cpp
diff --git a/intern/cycles/blender/addon/__init__.py b/intern/cycles/blender/addon/__init__.py
index 979e3e872d7..ccb04eea0a8 100644
--- a/intern/cycles/blender/addon/__init__.py
+++ b/intern/cycles/blender/addon/__init__.py
@@ -16,17 +16,20 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 #
 
+# <pep8 compliant>
+
 bl_info = {
     "name": "Cycles Render Engine",
     "author": "",
-    "version": (0,0),
-    "blender": (2, 5, 6),
-    "api": 34462,
+    "version": (0, 0),
+    "blender": (2, 6, 0),
+    "api": 41670,
     "location": "Info header, render engine menu",
     "description": "Cycles Render Engine integration.",
     "warning": "",
-    "wiki_url": "",
+    "wiki_url": "http://wiki.blender.org/index.php/Dev:2.6/Source/Render/Cycles",
     "tracker_url": "",
+    "support": 'OFFICIAL',
     "category": "Render"}
 
 import bpy
@@ -37,6 +40,7 @@ from cycles import xml
 from cycles import engine
 from cycles import presets
 
+
 class CyclesRender(bpy.types.RenderEngine):
     bl_idname = 'CYCLES'
     bl_label = "Cycles"
@@ -45,7 +49,7 @@ class CyclesRender(bpy.types.RenderEngine):
     def __init__(self):
         engine.init()
         self.session = None
-    
+
     def __del__(self):
         engine.free(self)
 
@@ -63,7 +67,7 @@ class CyclesRender(bpy.types.RenderEngine):
     #
     # def preview_render(self):
     #    pass
-    
+
     # viewport render
     def view_update(self, context):
         if not self.session:
@@ -74,6 +78,7 @@ class CyclesRender(bpy.types.RenderEngine):
     def view_draw(self, context):
         engine.draw(self, context.region, context.space_data, context.region_data)
 
+
 def register():
     properties.register()
     ui.register()
@@ -81,10 +86,10 @@ def register():
     presets.register()
     bpy.utils.register_module(__name__)
 
+
 def unregister():
     xml.unregister()
     ui.unregister()
     properties.unregister()
     presets.unregister()
     bpy.utils.unregister_module(__name__)
-
diff --git a/intern/cycles/blender/addon/engine.py b/intern/cycles/blender/addon/engine.py
index 097909ca058..a32a9e91499 100644
--- a/intern/cycles/blender/addon/engine.py
+++ b/intern/cycles/blender/addon/engine.py
@@ -16,8 +16,11 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 #
 
+# <pep8 compliant>
+
 import bpy
 
+
 def init():
     import bcycles
     import os.path
@@ -27,7 +30,8 @@ def init():
 
     bcycles.init(path, user_path)
 
-def create(engine, data, scene, region = 0, v3d = 0, rv3d = 0):
+
+def create(engine, data, scene, region=0, v3d=0, rv3d=0):
     import bcycles
 
     data = data.as_pointer()
@@ -41,20 +45,29 @@ def create(engine, data, scene, region = 0, v3d = 0, rv3d = 0):
 
     engine.session = bcycles.create(engine.as_pointer(), data, scene, region, v3d, rv3d)
 
+
 def free(engine):
-    if "session" in dir(engine):
+    if hasattr(engine, "session"):
         if engine.session:
             import bcycles
             bcycles.free(engine.session)
         del engine.session
 
+
 def render(engine):
     import bcycles
-    bcycles.render(engine.session)
+    if "session" in dir(engine):
+        bcycles.render(engine.session)
+
 
 def update(engine, data, scene):
     import bcycles
-    bcycles.sync(engine.session)
+    if scene.render.use_border:
+        engine.report({'ERROR'}, "Border rendering not supported yet")
+        free(engine)
+    else:
+        bcycles.sync(engine.session)
+
 
 def draw(engine, region, v3d, rv3d):
     import bcycles
@@ -64,11 +77,12 @@ def draw(engine, region, v3d, rv3d):
     # draw render image
     bcycles.draw(engine.session, v3d, rv3d)
 
+
 def available_devices():
     import bcycles
     return bcycles.available_devices()
 
+
 def with_osl():
     import bcycles
     return bcycles.with_osl()
-
diff --git a/intern/cycles/blender/addon/enums.py b/intern/cycles/blender/addon/enums.py
index 4aef2553050..463fdc19534 100644
--- a/intern/cycles/blender/addon/enums.py
+++ b/intern/cycles/blender/addon/enums.py
@@ -16,8 +16,11 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 #
 
+# <pep8 compliant>
+
 from cycles import engine
 
+
 def get_gpu_device():
     available_devices = engine.available_devices()
     cuda = 'cuda' in available_devices
@@ -28,32 +31,36 @@ def get_gpu_device():
         gpu_string = "CUDA GPU"
     else:
         gpu_string = "OpenCL GPU"
-    
+
     return gpu_string
 
 devices = (
-("CPU", "CPU", "Processor"),
-("GPU", get_gpu_device(), "Graphics card"))
+    ("CPU", "CPU", "Processor"),
+    ("GPU", get_gpu_device(), "Graphics card"),
+    )
 
 gpu_type = (
-("CUDA", "CUDA", "NVidia only"),
-("OPENCL", "OpenCL (incomplete)", ""))
+    ("CUDA", "CUDA", "NVidia only"),
+    ("OPENCL", "OpenCL (incomplete)", ""),
+    )
 
 shading_systems = (
-("GPU_COMPATIBLE", "GPU Compatible", "Restricted shading system compatible with GPU rendering"),
-("OSL", "Open Shading Language", "Open Shading Language shading system that only runs on the CPU"))
+    ("GPU_COMPATIBLE", "GPU Compatible", "Restricted shading system compatible with GPU rendering"),
+    ("OSL", "Open Shading Language", "Open Shading Language shading system that only runs on the CPU"),
+    )
 
 displacement_methods = (
-("BUMP", "Bump", "Bump mapping to simulate the appearance of displacement"),
-("TRUE", "True", "Use true displacement only, requires fine subdivision"),
-("BOTH", "Both", "Combination of displacement and bump mapping"))
+    ("BUMP", "Bump", "Bump mapping to simulate the appearance of displacement"),
+    ("TRUE", "True", "Use true displacement only, requires fine subdivision"),
+    ("BOTH", "Both", "Combination of displacement and bump mapping"),
+    )
 
 bvh_types = (
-("DYNAMIC_BVH", "Dynamic BVH", "Objects can be individually updated, at the cost of slower render time"),
-("STATIC_BVH", "Static BVH", "Any object modification requires a complete BVH rebuild, but renders faster"))
+    ("DYNAMIC_BVH", "Dynamic BVH", "Objects can be individually updated, at the cost of slower render time"),
+    ("STATIC_BVH", "Static BVH", "Any object modification requires a complete BVH rebuild, but renders faster"),
+    )
 
 filter_types = (
-("BOX", "Box", "Box filter"),
-("GAUSSIAN", "Gaussian", "Gaussian filter"))
-
-
+    ("BOX", "Box", "Box filter"),
+    ("GAUSSIAN", "Gaussian", "Gaussian filter"),
+    )
diff --git a/intern/cycles/blender/addon/presets.py b/intern/cycles/blender/addon/presets.py
index e5243b633be..e2836b2cc21 100644
--- a/intern/cycles/blender/addon/presets.py
+++ b/intern/cycles/blender/addon/presets.py
@@ -16,9 +16,12 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 #
 
+# <pep8 compliant>
+
 from bl_operators.presets import AddPresetBase
 from bpy.types import Operator
 
+
 class AddPresetIntegrator(AddPresetBase, Operator):
     '''Add an Integrator Preset'''
     bl_idname = "render.cycles_integrator_preset_add"
@@ -41,13 +44,14 @@ class AddPresetIntegrator(AddPresetBase, Operator):
     ]
 
     preset_subdir = "cycles/integrator"
-    
+
+
 def register():
     pass
 
+
 def unregister():
     pass
-    
+
 if __name__ == "__main__":
     register()
-
diff --git a/intern/cycles/blender/addon/properties.py b/intern/cycles/blender/addon/properties.py
index 5a56240865a..0c7deb01ed8 100644
--- a/intern/cycles/blender/addon/properties.py
+++ b/intern/cycles/blender/addon/properties.py
@@ -16,6 +16,8 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 #
 
+# <pep8 compliant>
+
 import bpy
 from bpy.props import *
 
@@ -23,6 +25,7 @@ import math
 
 from cycles import enums
 
+
 class CyclesRenderSettings(bpy.types.PropertyGroup):
     @classmethod
     def register(cls):
@@ -30,7 +33,7 @@ class CyclesRenderSettings(bpy.types.PropertyGroup):
 
         cls.device = EnumProperty(name="Device", description="Device to use for rendering",
             items=enums.devices, default="CPU")
-            
+
         cls.gpu_type = EnumProperty(name="GPU Type", description="Processing system to use on the GPU",
             items=enums.gpu_type, default="CUDA")
 
@@ -101,6 +104,7 @@ class CyclesRenderSettings(bpy.types.PropertyGroup):
     def unregister(cls):
         del bpy.types.Scene.cycles
 
+
 class CyclesCameraSettings(bpy.types.PropertyGroup):
     @classmethod
     def register(cls):
@@ -108,26 +112,28 @@ class CyclesCameraSettings(bpy.types.PropertyGroup):
 
         cls.aperture_size = FloatProperty(name="Aperture Size", description="Radius of the aperture for depth of field",
             default=0.0, min=0.0, max=10.0)
-        cls.aperture_blades = IntProperty(name="Aperture Blades", description="Number of blades in aperture for polygonal bokeh (need 3 or more)",
+        cls.aperture_blades = IntProperty(name="Aperture Blades", description="Number of blades in aperture for polygonal bokeh (at least 3)",
             default=0, min=0, max=100)
         cls.aperture_rotation = FloatProperty(name="Aperture Rotation", description="Rotation of blades in aperture",
             default=0, soft_min=-math.pi, soft_max=math.pi, subtype='ANGLE')
-    
+
     @classmethod
     def unregister(cls):
         del bpy.types.Camera.cycles
 
+
 class CyclesMaterialSettings(bpy.types.PropertyGroup):
     @classmethod
     def register(cls):
         bpy.types.Material.cycles = PointerProperty(type=cls, name="Cycles Material Settings", description="Cycles material settings")
-        cls.sample_as_light = BoolProperty(name="Sample as Light", description="Use direct light sampling, to reduce noise for small or strong emitting materials", default=True)
+        cls.sample_as_light = BoolProperty(name="Sample as Lamp", description="Use direct light sampling for this material, disabling may reduce overall noise for large objects that emit little light compared to other light sources", default=True)
         cls.homogeneous_volume = BoolProperty(name="Homogeneous Volume", description="When using volume rendering, assume volume has the same density everywhere, for faster rendering", default=False)
 
     @classmethod
     def unregister(cls):
         del bpy.types.Material.cycles
 
+
 class CyclesLampSettings(bpy.types.PropertyGroup):
     @classmethod
     def register(cls):
@@ -138,6 +144,7 @@ class CyclesLampSettings(bpy.types.PropertyGroup):
     def unregister(cls):
         del bpy.types.Lamp.cycles
 
+
 class CyclesWorldSettings(bpy.types.PropertyGroup):
     @classmethod
     def register(cls):
@@ -147,6 +154,7 @@ class CyclesWorldSettings(bpy.types.PropertyGroup):
     def unregister(cls):
         del bpy.types.World.cycles
 
+
 class CyclesVisibilitySettings(bpy.types.PropertyGroup):
     @classmethod
     def register(cls):
@@ -162,6 +170,7 @@ class CyclesVisibilitySettings(bpy.types.PropertyGroup):
     def unregister(cls):
         del bpy.types.Object.cycles_visibility
 
+
 class CyclesMeshSettings(bpy.types.PropertyGroup):
     @classmethod
     def register(cls):
@@ -181,6 +190,7 @@ class CyclesMeshSettings(bpy.types.PropertyGroup):
         del bpy.types.Curve.cycles
         del bpy.types.MetaBall.cycles
 
+
 def register():
     bpy.utils.register_class(CyclesRenderSettings)
     bpy.utils.register_class(CyclesCameraSettings)
@@ -189,7 +199,8 @@ def register():
     bpy.utils.register_class(CyclesWorldSettings)
     bpy.utils.register_class(CyclesVisibilitySettings)
     bpy.utils.register_class(CyclesMeshSettings)
-    
+
+
 def unregister():
     bpy.utils.unregister_class(CyclesRenderSettings)
     bpy.utils.unregister_class(CyclesCameraSettings)
@@ -198,4 +209,3 @@ def unregister():
     bpy.utils.unregister_class(CyclesWorldSettings)
     bpy.utils.unregister_class(CyclesMeshSettings)
     bpy.utils.unregister_class(CyclesVisibilitySettings)
-
diff --git a/intern/cycles/blender/addon/ui.py b/intern/cycles/blender/addon/ui.py
index 7c7d4c81b89..f3ed3b677fb 100644
--- a/intern/cycles/blender/addon/ui.py
+++ b/intern/cycles/blender/addon/ui.py
@@ -16,6 +16,8 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 #
 
+# <pep8 compliant>
+
 import bpy
 
 from bpy.types import Panel, Menu
@@ -23,6 +25,7 @@ from bpy.types import Panel, Menu
 from cycles import enums
 from cycles import engine
 
+
 class CYCLES_MT_integrator_presets(Menu):
     bl_label = "Integrator Presets"
     preset_subdir = "cycles/integrator"
@@ -30,16 +33,18 @@ class CYCLES_MT_integrator_presets(Menu):
     COMPAT_ENGINES = {'CYCLES'}
     draw = Menu.draw_preset
 
+
 class CyclesButtonsPanel():
     bl_space_type = "PROPERTIES"
     bl_region_type = "WINDOW"
     bl_context = "render"
-    
+
     @classmethod
     def poll(cls, context):
         rd = context.scene.render
         return rd.engine == 'CYCLES'
 
+
 class CyclesRender_PT_integrator(CyclesButtonsPanel, Panel):
     bl_label = "Integrator"
     bl_options = {'DEFAULT_CLOSED'}
@@ -49,7 +54,7 @@ class CyclesRender_PT_integrator(CyclesButtonsPanel, Panel):
 
         scene = context.scene
         cscene = scene.cycles
-        
+
         row = layout.row(align=True)
         row.menu("CYCLES_MT_integrator_presets", text=bpy.types.CYCLES_MT_integrator_presets.bl_label)
         row.operator("render.cycles_integrator_preset_add", text="", icon="ZOOMIN")
@@ -87,7 +92,8 @@ class CyclesRender_PT_integrator(CyclesButtonsPanel, Panel):
         #row = col.row()
         #row.prop(cscene, "blur_caustics")
         #row.active = not cscene.no_caustics
-        
+
+
 class CyclesRender_PT_film(CyclesButtonsPanel, Panel):
     bl_label = "Film"
 
@@ -99,7 +105,7 @@ class CyclesRender_PT_film(CyclesButtonsPanel, Panel):
 
         split = layout.split()
 
-        col = split.column();
+        col = split.column()
         col.prop(cscene, "film_exposure")
         col.prop(cscene, "film_transparent")
 
@@ -109,6 +115,7 @@ class CyclesRender_PT_film(CyclesButtonsPanel, Panel):
         if cscene.filter_type != 'BOX':
             sub.prop(cscene, "filter_width", text="Width")
 
+
 class CyclesRender_PT_performance(CyclesButtonsPanel, Panel):
     bl_label = "Performance"
     bl_options = {'DEFAULT_CLOSED'}
@@ -142,6 +149,7 @@ class CyclesRender_PT_performance(CyclesButtonsPanel, Panel):
         sub.prop(cscene, "debug_bvh_type", text="")
         sub.prop(cscene, "debug_use_spatial_splits")
 
+
 class CyclesRender_PT_layers(CyclesButtonsPanel, Panel):
     bl_label = "Layers"
     bl_options = {'DEFAULT_CLOSED'}
@@ -178,6 +186,7 @@ class CyclesRender_PT_layers(CyclesButtonsPanel, Panel):
 
         layout.prop(rl, "material_override", text="Material")
 
+
 class Cycles_PT_post_processing(CyclesButtonsPanel, Panel):
     bl_label = "Post Processing"
     bl_options = {'DEFAULT_CLOSED'}
@@ -196,6 +205,7 @@ class Cycles_PT_post_processing(CyclesButtonsPanel, Panel):
         col = split.column()
         col.prop(rd, "dither_intensity", text="Dither", slider=True)
 
+
 class CyclesCamera_PT_dof(CyclesButtonsPanel, Panel):
     bl_label = "Depth of Field"
     bl_context = "data"
@@ -229,6 +239,7 @@ class CyclesCamera_PT_dof(CyclesButtonsPanel, Panel):
         sub.prop(ccam, "aperture_blades", text="Blades")
         sub.prop(ccam, "aperture_rotation", text="Rotation")
 
+
 class Cycles_PT_context_material(CyclesButtonsPanel, Panel):
     bl_label = "Surface"
     bl_context = "material"
@@ -277,13 +288,14 @@ class Cycles_PT_context_material(CyclesButtonsPanel, Panel):
             split.template_ID(space, "pin_id")
             split.separator()
 
+
 class Cycles_PT_mesh_displacement(CyclesButtonsPanel, Panel):
     bl_label = "Displacement"
     bl_context = "data"
 
     @classmethod
     def poll(cls, context):
-        return context.mesh or context.curve or context.meta_ball
+        return CyclesButtonsPanel.poll(context) and (context.mesh or context.curve or context.meta_ball)
 
     def draw(self, context):
         layout = self.layout
@@ -300,8 +312,9 @@ class Cycles_PT_mesh_displacement(CyclesButtonsPanel, Panel):
             cdata = mball.cycles
 
         layout.prop(cdata, "displacement_method", text="Method")
-        layout.prop(cdata, "use_subdivision");
-        layout.prop(cdata, "dicing_rate");
+        layout.prop(cdata, "use_subdivision")
+        layout.prop(cdata, "dicing_rate")
+
 
 class CyclesObject_PT_ray_visibility(CyclesButtonsPanel, Panel):
     bl_label = "Ray Visibility"
@@ -311,7 +324,7 @@ class CyclesObject_PT_ray_visibility(CyclesButtonsPanel, Panel):
     @classmethod
     def poll(cls, context):
         ob = context.object
-        return CyclesButtonsPanel.poll(context) and ob and ob.type in ('MESH', 'CURVE', 'CURVE', 'SURFACE', 'FONT', 'META') # todo: 'LAMP'
+        return CyclesButtonsPanel.poll(context) and ob and ob.type in ('MESH', 'CURVE', 'CURVE', 'SURFACE', 'FONT', 'META')  # todo: 'LAMP'
 
     def draw(self, context):
         layout = self.layout
@@ -330,6 +343,7 @@ class CyclesObject_PT_ray_visibility(CyclesButtonsPanel, Panel):
         col.prop(visibility, "transmission")
         col.prop(visibility, "shadow")
 
+
 def find_node(material, nodetype):
     if material and material.node_tree:
         ntree = material.node_tree
@@ -337,16 +351,18 @@ def find_node(material, nodetype):
         for node in ntree.nodes:
             if hasattr(node, 'type') and node.type == nodetype:
                 return node
-    
+
     return None
 
+
 def find_node_input(node, name):
     for input in node.inputs:
         if input.name == name:
             return input
-    
+
     return None
 
+
 def panel_node_draw(layout, id, output_type, input_name):
     if not id.node_tree:
         layout.prop(id, "use_nodes", icon='NODETREE')
@@ -359,10 +375,11 @@ def panel_node_draw(layout, id, output_type, input_name):
         layout.label(text="No output node.")
     else:
         input = find_node_input(node, input_name)
-        layout.template_node_view(ntree, node, input);
-    
+        layout.template_node_view(ntree, node, input)
+
     return True
 
+
 class CyclesLamp_PT_lamp(CyclesButtonsPanel, Panel):
     bl_label = "Lamp"
     bl_context = "data"
@@ -401,7 +418,8 @@ class CyclesLamp_PT_lamp(CyclesButtonsPanel, Panel):
             layout.label(text="Not supported, interpreted as point lamp.")
         elif lamp.type == 'HEMI':
             layout.label(text="Not supported, interpreted as sun lamp.")
-   
+
+
 class CyclesLamp_PT_nodes(CyclesButtonsPanel, Panel):
     bl_label = "Nodes"
     bl_context = "data"
@@ -417,6 +435,7 @@ class CyclesLamp_PT_nodes(CyclesButtonsPanel, Panel):
         if not panel_node_draw(layout, lamp, 'OUTPUT_LAMP', 'Surface'):
             layout.prop(lamp, "color")
 
+
 class CyclesWorld_PT_surface(CyclesButtonsPanel, Panel):
     bl_label = "Surface"
     bl_context = "world"
@@ -432,6 +451,7 @@ class CyclesWorld_PT_surface(CyclesButtonsPanel, Panel):
         if not panel_node_draw(layout, world, 'OUTPUT_WORLD', 'Surface'):
             layout.prop(world, "horizon_color", text="Color")
 
+
 class CyclesWorld_PT_volume(CyclesButtonsPanel, Panel):
     bl_label = "Volume"
     bl_context = "world"
@@ -439,8 +459,8 @@ class CyclesWorld_PT_volume(CyclesButtonsPanel, Panel):
 
     @classmethod
     def poll(cls, context):
-        world = context.world
-        return False # world and world.node_tree and CyclesButtonsPanel.poll(context)
+        # world = context.world
+        return False  # world and world.node_tree and CyclesButtonsPanel.poll(context)
 
     def draw(self, context):
         layout = self.layout
@@ -449,6 +469,7 @@ class CyclesWorld_PT_volume(CyclesButtonsPanel, Panel):
         world = context.world
         panel_node_draw(layout, world, 'OUTPUT_WORLD', 'Volume')
 
+
 class CyclesMaterial_PT_surface(CyclesButtonsPanel, Panel):
     bl_label = "Surface"
     bl_context = "material"
@@ -464,6 +485,7 @@ class CyclesMaterial_PT_surface(CyclesButtonsPanel, Panel):
         if not panel_node_draw(layout, mat, 'OUTPUT_MATERIAL', 'Surface'):
             layout.prop(mat, "diffuse_color")
 
+
 class CyclesMaterial_PT_volume(CyclesButtonsPanel, Panel):
     bl_label = "Volume"
     bl_context = "material"
@@ -471,8 +493,8 @@ class CyclesMaterial_PT_volume(CyclesButtonsPanel, Panel):
 
     @classmethod
     def poll(cls, context):
-        mat = context.material
-        return False #mat and mat.node_tree and CyclesButtonsPanel.poll(context)
+        # mat = context.material
+        return False  # mat and mat.node_tree and CyclesButtonsPanel.poll(context)
 
     def draw(self, context):
         layout = self.layout
@@ -485,6 +507,7 @@ class CyclesMaterial_PT_volume(CyclesButtonsPanel, Panel):
 
         layout.prop(cmat, "homogeneous_volume")
 
+
 class CyclesMaterial_PT_displacement(CyclesButtonsPanel, Panel):
     bl_label = "Displacement"
     bl_context = "material"
@@ -500,6 +523,7 @@ class CyclesMaterial_PT_displacement(CyclesButtonsPanel, Panel):
         mat = context.material
         panel_node_draw(layout, mat, 'OUTPUT_MATERIAL', 'Displacement')
 
+
 class CyclesMaterial_PT_settings(CyclesButtonsPanel, Panel):
     bl_label = "Settings"
     bl_context = "material"
@@ -523,6 +547,7 @@ class CyclesMaterial_PT_settings(CyclesButtonsPanel, Panel):
         col = split.column()
         col.prop(cmat, "sample_as_light")
 
+
 class CyclesTexture_PT_context(CyclesButtonsPanel, Panel):
     bl_label = ""
     bl_context = "texture"
@@ -535,9 +560,9 @@ class CyclesTexture_PT_context(CyclesButtonsPanel, Panel):
         tex = context.texture
         space = context.space_data
         pin_id = space.pin_id
-        use_pin_id = space.use_pin_id;
+        use_pin_id = space.use_pin_id
         user = context.texture_user
-        node = context.texture_node
+        # node = context.texture_node
 
         if not use_pin_id or not isinstance(pin_id, bpy.types.Texture):
             pin_id = None
@@ -555,7 +580,7 @@ class CyclesTexture_PT_context(CyclesButtonsPanel, Panel):
                 col.template_ID(space, "pin_id")
             elif user:
                 col.template_ID(user, "texture", new="texture.new")
-            
+
             if tex:
                 row = split.row()
                 row.prop(tex, "use_nodes", icon="NODETREE", text="")
@@ -566,6 +591,7 @@ class CyclesTexture_PT_context(CyclesButtonsPanel, Panel):
                     split.label(text="Type:")
                     split.prop(tex, "type", text="")
 
+
 class CyclesTexture_PT_nodes(CyclesButtonsPanel, Panel):
     bl_label = "Nodes"
     bl_context = "texture"
@@ -581,6 +607,7 @@ class CyclesTexture_PT_nodes(CyclesButtonsPanel, Panel):
         tex = context.texture
         panel_node_draw(layout, tex, 'OUTPUT_TEXTURE', 'Color')
 
+
 class CyclesTexture_PT_node(CyclesButtonsPanel, Panel):
     bl_label = "Node"
     bl_context = "texture"
@@ -597,6 +624,7 @@ class CyclesTexture_PT_node(CyclesButtonsPanel, Panel):
         ntree = node.id_data
         layout.template_node_view(ntree, node, None)
 
+
 class CyclesTexture_PT_mapping(CyclesButtonsPanel, Panel):
     bl_label = "Mapping"
     bl_context = "texture"
@@ -610,7 +638,7 @@ class CyclesTexture_PT_mapping(CyclesButtonsPanel, Panel):
     def draw(self, context):
         layout = self.layout
 
-        tex = context.texture
+        # tex = context.texture
         node = context.texture_node
 
         mapping = node.texture_mapping
@@ -628,6 +656,7 @@ class CyclesTexture_PT_mapping(CyclesButtonsPanel, Panel):
         row.prop(mapping, "mapping_y", text="")
         row.prop(mapping, "mapping_z", text="")
 
+
 class CyclesTexture_PT_colors(CyclesButtonsPanel, Panel):
     bl_label = "Color"
     bl_context = "texture"
@@ -635,15 +664,15 @@ class CyclesTexture_PT_colors(CyclesButtonsPanel, Panel):
 
     @classmethod
     def poll(cls, context):
-        tex = context.texture
-        node = context.texture_node
+        # tex = context.texture
+        # node = context.texture_node
         return False
         #return (node or (tex and tex.use_nodes)) and CyclesButtonsPanel.poll(context)
 
     def draw(self, context):
         layout = self.layout
 
-        tex = context.texture
+        # tex = context.texture
         node = context.texture_node
 
         mapping = node.color_mapping
@@ -668,6 +697,7 @@ class CyclesTexture_PT_colors(CyclesButtonsPanel, Panel):
         if mapping.use_color_ramp:
             layout.template_color_ramp(mapping, "color_ramp", expand=True)
 
+
 def draw_device(self, context):
     scene = context.scene
     layout = self.layout
@@ -686,6 +716,7 @@ def draw_device(self, context):
         if cscene.device == 'CPU' and engine.with_osl():
             layout.prop(cscene, "shading_system")
 
+
 def draw_pause(self, context):
     layout = self.layout
     scene = context.scene
@@ -697,6 +728,7 @@ def draw_pause(self, context):
             cscene = scene.cycles
             layout.prop(cscene, "preview_pause", icon="PAUSE", text="")
 
+
 def get_panels():
     return [
         bpy.types.RENDER_PT_render,
@@ -752,17 +784,18 @@ def get_panels():
         bpy.types.PARTICLE_PT_vertexgroups,
         bpy.types.PARTICLE_PT_custom_props]
 
+
 def register():
     bpy.types.RENDER_PT_render.append(draw_device)
     bpy.types.VIEW3D_HT_header.append(draw_pause)
 
     for panel in get_panels():
         panel.COMPAT_ENGINES.add('CYCLES')
-    
+
+
 def unregister():
     bpy.types.RENDER_PT_render.remove(draw_device)
     bpy.types.VIEW3D_HT_header.remove(draw_pause)
 
     for panel in get_panels():
         panel.COMPAT_ENGINES.remove('CYCLES')
-
diff --git a/intern/cycles/blender/addon/xml.py b/intern/cycles/blender/addon/xml.py
index 3713da09235..e64023f046b 100644
--- a/intern/cycles/blender/addon/xml.py
+++ b/intern/cycles/blender/addon/xml.py
@@ -16,6 +16,8 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 #
 
+# <pep8 compliant>
+
 # XML exporter for generating test files, not intended for end users
 
 import os
@@ -24,6 +26,7 @@ from bpy_extras.io_utils import ExportHelper
 import xml.etree.ElementTree as etree
 import xml.dom.minidom as dom
 
+
 def strip(root):
     root.text = None
     root.tail = None
@@ -31,6 +34,7 @@ def strip(root):
     for elem in root:
         strip(elem)
 
+
 def write(node, fname):
     strip(node)
 
@@ -40,6 +44,7 @@ def write(node, fname):
     f = open(fname, "w")
     f.write(s)
 
+
 class ExportCyclesXML(bpy.types.Operator, ExportHelper):
     ''''''
     bl_idname = "export_mesh.cycles_xml"
@@ -82,18 +87,19 @@ class ExportCyclesXML(bpy.types.Operator, ExportHelper):
             verts += " "
 
         node = etree.Element('mesh', attrib={'nverts': nverts, 'verts': verts, 'P': P})
-        
+
         # write to file
         write(node, filepath)
 
         return {'FINISHED'}
 
+
 def register():
     pass
 
+
 def unregister():
     pass
 
 if __name__ == "__main__":
     register()
-
diff --git a/intern/cycles/blender/blender_shader.cpp b/intern/cycles/blender/blender_shader.cpp
index 6f78fe1f0d4..a6ce0e9bfa8 100644
--- a/intern/cycles/blender/blender_shader.cpp
+++ b/intern/cycles/blender/blender_shader.cpp
@@ -100,7 +100,7 @@ static float get_node_output_value(BL::Node b_node, const string& name)
 static void get_tex_mapping(TextureMapping *mapping, BL::TexMapping b_mapping)
 {
 	mapping->translation = get_float3(b_mapping.location());
-	mapping->rotation = get_float3(b_mapping.rotation())*(M_PI/180.0f); /* in degrees! */
+	mapping->rotation = get_float3(b_mapping.rotation());
 	mapping->scale = get_float3(b_mapping.scale());
 
 	mapping->x_mapping = (TextureMapping::Mapping)b_mapping.mapping_x();
@@ -108,6 +108,13 @@ static void get_tex_mapping(TextureMapping *mapping, BL::TexMapping b_mapping)
 	mapping->z_mapping = (TextureMapping::Mapping)b_mapping.mapping_z();
 }
 
+static void get_tex_mapping(TextureMapping *mapping, BL::ShaderNodeMapping b_mapping)
+{
+	mapping->translation = get_float3(b_mapping.location());
+	mapping->rotation = get_float3(b_mapping.rotation());
+	mapping->scale = get_float3(b_mapping.scale());
+}
+
 static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *b_group_node, BL::ShaderNode b_node)
 {
 	ShaderNode *node = NULL;
@@ -174,7 +181,7 @@ static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *
 			BL::ShaderNodeMapping b_mapping_node(b_node);
 			MappingNode *mapping = new MappingNode();
 
-			get_tex_mapping(&mapping->tex_mapping, b_mapping_node.mapping());
+			get_tex_mapping(&mapping->tex_mapping, b_mapping_node);
 
 			node = mapping;
 			break;
diff --git a/intern/cycles/blender/blender_util.h b/intern/cycles/blender/blender_util.h
index c5cceff6242..ff6d55c6f3e 100644
--- a/intern/cycles/blender/blender_util.h
+++ b/intern/cycles/blender/blender_util.h
@@ -176,7 +176,13 @@ static inline string get_enum_identifier(PointerRNA& ptr, const char *name)
 static inline string blender_absolute_path(BL::BlendData b_data, BL::ID b_id, const string& path)
 {
 	if(path.size() >= 2 && path[0] == '/' && path[1] == '/') {
-		string dirname = (b_id.library())? b_id.library().filepath(): b_data.filepath();
+		string dirname;
+		
+		if(b_id.library())
+			dirname = blender_absolute_path(b_data, b_id.library(), b_id.library().filepath());
+		else
+			dirname = b_data.filepath();
+
 		return path_join(path_dirname(dirname), path.substr(2));
 	}
 
diff --git a/intern/cycles/cmake/external_libs.cmake b/intern/cycles/cmake/external_libs.cmake
index 9037362f1ab..7d12e261068 100644
--- a/intern/cycles/cmake/external_libs.cmake
+++ b/intern/cycles/cmake/external_libs.cmake
@@ -71,21 +71,6 @@ if(WITH_CYCLES_PARTIO)
 endif()
 
 ###########################################################################
-# Blender
-
-if(WITH_CYCLES_BLENDER)
-
-	set(BLENDER_INCLUDE_DIRS
-		${CMAKE_SOURCE_DIR}/intern/guardedalloc
-		${CMAKE_SOURCE_DIR}/source/blender/makesdna
-		${CMAKE_SOURCE_DIR}/source/blender/makesrna
-		${CMAKE_SOURCE_DIR}/source/blender/blenloader
-		${CMAKE_BINARY_DIR}/source/blender/makesrna/intern)
-
-	add_definitions(-DBLENDER_PLUGIN)
-endif()
-
-###########################################################################
 # CUDA
 
 if(WITH_CYCLES_CUDA_BINARIES)
diff --git a/intern/cycles/device/device_cpu.cpp b/intern/cycles/device/device_cpu.cpp
index d6e1c200996..990b7cb94b0 100644
--- a/intern/cycles/device/device_cpu.cpp
+++ b/intern/cycles/device/device_cpu.cpp
@@ -48,6 +48,9 @@ public:
 	{
 		kg = kernel_globals_create();
 
+		/* do now to avoid thread issues */
+		system_cpu_support_optimized();
+
 		if(threads_num == 0)
 			threads_num = system_cpu_thread_count();
 
@@ -155,12 +158,26 @@ public:
 			OSLShader::thread_init(kg);
 #endif
 
-		for(int y = task.y; y < task.y + task.h; y++) {
-			for(int x = task.x; x < task.x + task.w; x++)
-				kernel_cpu_path_trace(kg, (float4*)task.buffer, (unsigned int*)task.rng_state, task.sample, x, y);
+#ifdef WITH_OPTIMIZED_KERNEL
+		if(system_cpu_support_optimized()) {
+			for(int y = task.y; y < task.y + task.h; y++) {
+				for(int x = task.x; x < task.x + task.w; x++)
+					kernel_cpu_optimized_path_trace(kg, (float4*)task.buffer, (unsigned int*)task.rng_state, task.sample, x, y);
 
-			if(tasks.worker_cancel())
-				break;
+				if(tasks.worker_cancel())
+					break;
+			}
+		}
+		else
+#endif
+		{
+			for(int y = task.y; y < task.y + task.h; y++) {
+				for(int x = task.x; x < task.x + task.w; x++)
+					kernel_cpu_path_trace(kg, (float4*)task.buffer, (unsigned int*)task.rng_state, task.sample, x, y);
+
+				if(tasks.worker_cancel())
+					break;
+			}
 		}
 
 #ifdef WITH_OSL
@@ -171,9 +188,18 @@ public:
 
 	void thread_tonemap(DeviceTask& task)
 	{
-		for(int y = task.y; y < task.y + task.h; y++) {
-			for(int x = task.x; x < task.x + task.w; x++)
-				kernel_cpu_tonemap(kg, (uchar4*)task.rgba, (float4*)task.buffer, task.sample, task.resolution, x, y);
+#ifdef WITH_OPTIMIZED_KERNEL
+		if(system_cpu_support_optimized()) {
+			for(int y = task.y; y < task.y + task.h; y++)
+				for(int x = task.x; x < task.x + task.w; x++)
+					kernel_cpu_optimized_tonemap(kg, (uchar4*)task.rgba, (float4*)task.buffer, task.sample, task.resolution, x, y);
+		}
+		else
+#endif
+		{
+			for(int y = task.y; y < task.y + task.h; y++)
+				for(int x = task.x; x < task.x + task.w; x++)
+					kernel_cpu_tonemap(kg, (uchar4*)task.rgba, (float4*)task.buffer, task.sample, task.resolution, x, y);
 		}
 	}
 
@@ -184,11 +210,24 @@ public:
 			OSLShader::thread_init(kg);
 #endif
 
-		for(int x = task.displace_x; x < task.displace_x + task.displace_w; x++) {
-			kernel_cpu_displace(kg, (uint4*)task.displace_input, (float3*)task.displace_offset, x);
+#ifdef WITH_OPTIMIZED_KERNEL
+		if(system_cpu_support_optimized()) {
+			for(int x = task.displace_x; x < task.displace_x + task.displace_w; x++) {
+				kernel_cpu_optimized_displace(kg, (uint4*)task.displace_input, (float3*)task.displace_offset, x);
+
+				if(tasks.worker_cancel())
+					break;
+			}
+		}
+		else
+#endif
+		{
+			for(int x = task.displace_x; x < task.displace_x + task.displace_w; x++) {
+				kernel_cpu_displace(kg, (uint4*)task.displace_input, (float3*)task.displace_offset, x);
 
-			if(tasks.worker_cancel())
-				break;
+				if(tasks.worker_cancel())
+					break;
+			}
 		}
 
 #ifdef WITH_OSL
diff --git a/intern/cycles/device/device_opencl.cpp b/intern/cycles/device/device_opencl.cpp
index d8df8025a08..c96d4617ffb 100644
--- a/intern/cycles/device/device_opencl.cpp
+++ b/intern/cycles/device/device_opencl.cpp
@@ -177,6 +177,7 @@ public:
 	bool opencl_version_check()
 	{
 		char version[256];
+
 		int major, minor, req_major = 1, req_minor = 1;
 
 		clGetPlatformInfo(cpPlatform, CL_PLATFORM_VERSION, sizeof(version), &version, NULL);
@@ -265,6 +266,20 @@ public:
 
 		build_options += "-I " + kernel_path + ""; /* todo: escape path */
 		build_options += " -cl-fast-relaxed-math ";
+		
+		/* Full Shading only on NVIDIA cards at the moment */
+		char vendor[256];
+
+		clGetPlatformInfo(cpPlatform, CL_PLATFORM_NAME, sizeof(vendor), &vendor, NULL);
+		string name = vendor;
+		
+		if (name == "NVIDIA CUDA") {
+			build_options += "-D __SVM__ ";
+			build_options += "-D __EMISSION__ ";
+			build_options += "-D __TEXTURES__ ";
+			build_options += "-D __HOLDOUT__ ";
+			build_options += "-D __MULTI_CLOSURE__ ";
+		}
 
 		ciErr = clBuildProgram(cpProgram, 0, NULL, build_options.c_str(), NULL, NULL);
 
diff --git a/intern/cycles/kernel/CMakeLists.txt b/intern/cycles/kernel/CMakeLists.txt
index 614391bd3f2..73425486be1 100644
--- a/intern/cycles/kernel/CMakeLists.txt
+++ b/intern/cycles/kernel/CMakeLists.txt
@@ -8,6 +8,7 @@ set(INC
 
 set(SRC
 	kernel.cpp
+	kernel_optimized.cpp
 	kernel.cl
 	kernel.cu
 )
@@ -42,6 +43,7 @@ set(SRC_SVM_HEADERS
 	svm/bsdf.h
 	svm/bsdf_ashikhmin_velvet.h
 	svm/bsdf_diffuse.h
+	svm/bsdf_oren_nayar.h
 	svm/bsdf_microfacet.h
 	svm/bsdf_reflection.h
 	svm/bsdf_refraction.h
@@ -122,11 +124,15 @@ include_directories(${INC})
 
 add_library(cycles_kernel ${SRC} ${SRC_HEADERS} ${SRC_SVM_HEADERS})
 
+if(WITH_CYCLES_OPTIMIZED_KERNEL)
+	SET_SOURCE_FILES_PROPERTIES(kernel_optimized.cpp PROPERTIES COMPILE_FLAGS ${CYCLES_OPTIMIZED_KERNEL_FLAGS})
+endif()
+
 if(WITH_CYCLES_CUDA)
 	add_dependencies(cycles_kernel cycles_kernel_cuda)
 endif()
 
-# OPENCL kernel
+# OpenCL kernel
 
 #set(KERNEL_PREPROCESSED ${CMAKE_CURRENT_BINARY_DIR}/kernel_preprocessed.cl)
 #add_custom_command(
@@ -141,3 +147,4 @@ delayed_install(${CMAKE_CURRENT_SOURCE_DIR} "kernel.cu" ${CYCLES_INSTALL_PATH}/k
 delayed_install(${CMAKE_CURRENT_SOURCE_DIR} "${SRC_HEADERS}" ${CYCLES_INSTALL_PATH}/kernel)
 delayed_install(${CMAKE_CURRENT_SOURCE_DIR} "${SRC_SVM_HEADERS}" ${CYCLES_INSTALL_PATH}/kernel/svm)
 delayed_install(${CMAKE_CURRENT_SOURCE_DIR} "${SRC_UTIL_HEADERS}" ${CYCLES_INSTALL_PATH}/kernel)
+
diff --git a/intern/cycles/kernel/kernel.h b/intern/cycles/kernel/kernel.h
index 7f60730e8bf..700ee49c5f2 100644
--- a/intern/cycles/kernel/kernel.h
+++ b/intern/cycles/kernel/kernel.h
@@ -38,9 +38,14 @@ void kernel_tex_copy(KernelGlobals *kg, const char *name, device_ptr mem, size_t
 
 void kernel_cpu_path_trace(KernelGlobals *kg, float4 *buffer, unsigned int *rng_state, int sample, int x, int y);
 void kernel_cpu_tonemap(KernelGlobals *kg, uchar4 *rgba, float4 *buffer, int sample, int resolution, int x, int y);
-
 void kernel_cpu_displace(KernelGlobals *kg, uint4 *input, float3 *offset, int i);
 
+#ifdef WITH_OPTIMIZED_KERNEL
+void kernel_cpu_optimized_path_trace(KernelGlobals *kg, float4 *buffer, unsigned int *rng_state, int sample, int x, int y);
+void kernel_cpu_optimized_tonemap(KernelGlobals *kg, uchar4 *rgba, float4 *buffer, int sample, int resolution, int x, int y);
+void kernel_cpu_optimized_displace(KernelGlobals *kg, uint4 *input, float3 *offset, int i);
+#endif
+
 CCL_NAMESPACE_END
 
 #endif /* __KERNEL_H__ */
diff --git a/intern/cycles/kernel/kernel_globals.h b/intern/cycles/kernel/kernel_globals.h
index a1b23128b38..ea866221487 100644
--- a/intern/cycles/kernel/kernel_globals.h
+++ b/intern/cycles/kernel/kernel_globals.h
@@ -49,7 +49,7 @@ typedef struct KernelGlobals {
 	OSLGlobals osl;
 #endif
 
-} KernelGLobals;
+} KernelGlobals;
 
 #endif
 
diff --git a/intern/cycles/kernel/kernel_optimized.cpp b/intern/cycles/kernel/kernel_optimized.cpp
new file mode 100644
index 00000000000..85a2b798a62
--- /dev/null
+++ b/intern/cycles/kernel/kernel_optimized.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2011, Blender Foundation.
+ *
+ * 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.
+ */
+
+/* Optimized CPU kernel entry points. This file is compiled with SSE3
+   optimization flags and nearly all functions inlined, while kernel.cpp
+   is compiled without for other CPU's. */
+
+#ifdef WITH_OPTIMIZED_KERNEL
+
+#include "kernel.h"
+#include "kernel_compat_cpu.h"
+#include "kernel_math.h"
+#include "kernel_types.h"
+#include "kernel_globals.h"
+#include "kernel_film.h"
+#include "kernel_path.h"
+#include "kernel_displace.h"
+
+CCL_NAMESPACE_BEGIN
+
+/* Path Tracing */
+
+void kernel_cpu_optimized_path_trace(KernelGlobals *kg, float4 *buffer, unsigned int *rng_state, int sample, int x, int y)
+{
+	kernel_path_trace(kg, buffer, rng_state, sample, x, y);
+}
+
+/* Tonemapping */
+
+void kernel_cpu_optimized_tonemap(KernelGlobals *kg, uchar4 *rgba, float4 *buffer, int sample, int resolution, int x, int y)
+{
+	kernel_film_tonemap(kg, rgba, buffer, sample, resolution, x, y);
+}
+
+/* Displacement */
+
+void kernel_cpu_optimized_displace(KernelGlobals *kg, uint4 *input, float3 *offset, int i)
+{
+	kernel_displace(kg, input, offset, i);
+}
+
+CCL_NAMESPACE_END
+
+#endif
+
diff --git a/intern/cycles/kernel/kernel_shader.h b/intern/cycles/kernel/kernel_shader.h
index ac0df71c38f..1647504207a 100644
--- a/intern/cycles/kernel/kernel_shader.h
+++ b/intern/cycles/kernel/kernel_shader.h
@@ -226,8 +226,7 @@ __device void shader_setup_from_displace(KernelGlobals *kg, ShaderData *sd,
 	Ng = triangle_normal_MT(kg, prim, &shader);
 
 	/* force smooth shading for displacement */
-	if(shader >= 0)
-		shader = -shader;
+	sd->shader |= SHADER_SMOOTH_NORMAL;
 
 	/* watch out: no instance transform currently */
 
diff --git a/intern/cycles/kernel/osl/CMakeLists.txt b/intern/cycles/kernel/osl/CMakeLists.txt
index ae88008cf71..13b2a39d7d0 100644
--- a/intern/cycles/kernel/osl/CMakeLists.txt
+++ b/intern/cycles/kernel/osl/CMakeLists.txt
@@ -12,6 +12,7 @@ set(SRC
 	background.cpp
 	bsdf_ashikhmin_velvet.cpp
 	bsdf_diffuse.cpp
+	bsdf_oren_nayar.cpp
 	bsdf_microfacet.cpp
 	bsdf_reflection.cpp
 	bsdf_refraction.cpp
diff --git a/intern/cycles/kernel/osl/bsdf_oren_nayar.cpp b/intern/cycles/kernel/osl/bsdf_oren_nayar.cpp
new file mode 100644
index 00000000000..a42c81e78f3
--- /dev/null
+++ b/intern/cycles/kernel/osl/bsdf_oren_nayar.cpp
@@ -0,0 +1,174 @@
+/*
+ * Copyright 2011, Blender Foundation.
+ *
+ * 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.
+ */
+
+/*
+ *	An implementation of Oren-Nayar reflectance model, public domain
+ *		http://www1.cs.columbia.edu/CAVE/publications/pdfs/Oren_SIGGRAPH94.pdf
+ *
+ *	NOTE:
+ *		BSDF = A + B * cos() * sin() * tan()
+ *
+ *		The parameter sigma means different from original.
+ *		A and B are calculated by the following formula:
+ *			0 <= sigma <= 1
+ *			A =     1 / ((1 + sigma / 2) * pi);
+ *			B = sigma / ((1 + sigma / 2) * pi);
+ *
+ *		This formula is derived as following:
+ *
+ *		0. Normalize A-term and B-term of BSDF *individually*.
+ *		   B-term is normalized at maximum point: dot(L, N) = 0.
+ *			A = (1/pi) * A'
+ *			B = (2/pi) * B'
+ *
+ *		1. Solve the following equation:
+ *			A' + B' = 1
+ *			B / A = sigma
+ */
+
+#include <OpenImageIO/fmath.h>
+#include <OSL/genclosure.h>
+#include "osl_closures.h"
+
+CCL_NAMESPACE_BEGIN
+
+using namespace OSL;
+
+
+class OrenNayarClosure: public BSDFClosure {
+public:
+	Vec3 m_N;
+	float m_sigma;
+	float m_a, m_b;
+
+	OrenNayarClosure(): BSDFClosure(Labels::DIFFUSE) {}
+
+	void setup() {
+		m_sigma = clamp(m_sigma, 0.0f, 1.0f);
+		m_a =    1.0f / ((1.0f + 0.5f * m_sigma) * M_PI);
+		m_b = m_sigma / ((1.0f + 0.5f * m_sigma) * M_PI);
+	}
+
+	bool mergeable(const ClosurePrimitive* other) const {
+		const OrenNayarClosure* comp = static_cast<const OrenNayarClosure*>(other);
+		return
+			m_N == comp->m_N &&
+			m_sigma == comp->m_sigma &&
+			BSDFClosure::mergeable(other);
+	}
+
+	size_t memsize() const {
+		return sizeof(*this);
+	}
+
+	const char* name() const {
+		return "oren_nayar";
+	}
+
+	void print_on(std::ostream& out) const {
+		out << name() << " (";
+		out << "(" << m_N[0] << ", " << m_N[1] << ", " << m_N[2] << "), ";
+		out << m_sigma;
+		out << ")";
+	}
+
+	float albedo(const Vec3& omega_out) const {
+		return 1.0f;
+	}
+
+	Color3 eval_reflect(const Vec3& omega_out, const Vec3& omega_in, float& pdf) const {
+		if (m_N.dot(omega_in) > 0.0f) {
+			pdf = float(0.5 * M_1_PI);
+			float is = get_intensity(m_N, omega_out, omega_in);
+			return Color3(is, is, is);
+		}
+		else {
+			pdf = 0.0f;
+			return Color3(0.0f, 0.0f, 0.0f);
+		}
+	}
+
+	Color3 eval_transmit(const Vec3& omega_out, const Vec3& omega_in, float& pdf) const {
+		return Color3(0.0f, 0.0f, 0.0f);
+	}
+
+	ustring sample(
+		const Vec3& Ng,
+		const Vec3& omega_out, const Vec3& domega_out_dx, const Vec3& domega_out_dy,
+		float randu, float randv,
+		Vec3& omega_in, Vec3& domega_in_dx, Vec3& domega_in_dy,
+		float& pdf, Color3& eval
+	) const {
+		sample_uniform_hemisphere (m_N, omega_out, randu, randv, omega_in, pdf);
+
+		if (Ng.dot(omega_in) > 0.0f) {
+			float is = get_intensity(m_N, omega_out, omega_in);
+			eval.setValue(is, is, is);
+
+			// TODO: find a better approximation for the bounce
+			domega_in_dx = (2.0f * m_N.dot(domega_out_dx)) * m_N - domega_out_dx;
+			domega_in_dy = (2.0f * m_N.dot(domega_out_dy)) * m_N - domega_out_dy;
+			domega_in_dx *= 125.0f;
+			domega_in_dy *= 125.0f;
+		}
+		else {
+			pdf = 0.0f;
+		}
+
+		return Labels::REFLECT;
+	}
+
+private:
+	float get_intensity(Vec3 const& n, Vec3 const& v, Vec3 const& l) const {
+		float nl = max(n.dot(l), 0.0f);
+		float nv = max(n.dot(v), 0.0f);
+
+		Vec3 al = l - nl * n;
+		al.normalize();
+		Vec3 av = v - nv * n;
+		av.normalize();
+		float t = max(al.dot(av), 0.0f);
+
+		float cos_a, cos_b;
+		if (nl < nv) {
+			cos_a = nl;
+			cos_b = nv;
+		}
+		else {
+			cos_a = nv;
+			cos_b = nl;
+		}
+
+		float sin_a = sqrtf(1.0f - cos_a * cos_a);
+		float tan_b = sqrtf(1.0f - cos_b * cos_b) / (cos_b + FLT_MIN);
+
+		return nl * (m_a + m_b * t * sin_a * tan_b);
+	}
+};
+
+ClosureParam bsdf_oren_nayar_params[] = {
+	CLOSURE_VECTOR_PARAM	(OrenNayarClosure, m_N),
+	CLOSURE_FLOAT_PARAM		(OrenNayarClosure, m_sigma),
+	CLOSURE_STRING_KEYPARAM ("label"),
+	CLOSURE_FINISH_PARAM	(OrenNayarClosure)
+};
+
+CLOSURE_PREPARE(bsdf_oren_nayar_prepare, OrenNayarClosure)
+
+
+CCL_NAMESPACE_END
diff --git a/intern/cycles/kernel/osl/nodes/node_diffuse_bsdf.osl b/intern/cycles/kernel/osl/nodes/node_diffuse_bsdf.osl
index 8cf161c17cc..6075b7c93f3 100644
--- a/intern/cycles/kernel/osl/nodes/node_diffuse_bsdf.osl
+++ b/intern/cycles/kernel/osl/nodes/node_diffuse_bsdf.osl
@@ -20,9 +20,13 @@
 
 shader node_diffuse_bsdf(
 	color Color = color(0.8, 0.8, 0.8),
+	float Roughness = 0.0,
 	normal Normal = N,
 	output closure color BSDF = diffuse(Normal))
 {
-	BSDF = Color*diffuse(Normal);
+	if(Roughness == 0.0)
+		BSDF = Color * diffuse(Normal);
+	else
+		BSDF = Color * oren_nayar(Normal, Roughness);
 }
 
diff --git a/intern/cycles/kernel/osl/nodes/stdosl.h b/intern/cycles/kernel/osl/nodes/stdosl.h
index 6fe4f52df4a..e4a110e737c 100644
--- a/intern/cycles/kernel/osl/nodes/stdosl.h
+++ b/intern/cycles/kernel/osl/nodes/stdosl.h
@@ -435,6 +435,7 @@ string concat (string a, string b, string c, string d, string e, string f) {
 // Closures
 
 closure color diffuse(normal N) BUILTIN;
+closure color oren_nayar(normal N, float sigma) BUILTIN;
 closure color translucent(normal N) BUILTIN;
 closure color reflection(normal N, float eta) BUILTIN;
 closure color reflection(normal N) { return reflection (N, 0.0); }
diff --git a/intern/cycles/kernel/osl/osl_closures.cpp b/intern/cycles/kernel/osl/osl_closures.cpp
index 4c2261942fd..b87cdf8af86 100644
--- a/intern/cycles/kernel/osl/osl_closures.cpp
+++ b/intern/cycles/kernel/osl/osl_closures.cpp
@@ -69,6 +69,7 @@ static void register_closure(OSL::ShadingSystem *ss, const char *name, int id, O
 void OSLShader::register_closures(OSL::ShadingSystem *ss)
 {
 	register_closure(ss, "diffuse", OSL_CLOSURE_BSDF_DIFFUSE_ID, bsdf_diffuse_params, bsdf_diffuse_prepare);
+	register_closure(ss, "oren_nayar", OSL_CLOSURE_BSDF_OREN_NAYAR_ID, bsdf_oren_nayar_params, bsdf_oren_nayar_prepare);
 	register_closure(ss, "translucent", OSL_CLOSURE_BSDF_TRANSLUCENT_ID, bsdf_translucent_params, bsdf_translucent_prepare);
 	register_closure(ss, "reflection", OSL_CLOSURE_BSDF_REFLECTION_ID, bsdf_reflection_params, bsdf_reflection_prepare);
 	register_closure(ss, "refraction", OSL_CLOSURE_BSDF_REFRACTION_ID, bsdf_refraction_params, bsdf_refraction_prepare);
diff --git a/intern/cycles/kernel/osl/osl_closures.h b/intern/cycles/kernel/osl/osl_closures.h
index 20a759586b0..1b4288b8601 100644
--- a/intern/cycles/kernel/osl/osl_closures.h
+++ b/intern/cycles/kernel/osl/osl_closures.h
@@ -41,6 +41,7 @@ CCL_NAMESPACE_BEGIN
 
 enum {
 	OSL_CLOSURE_BSDF_DIFFUSE_ID,
+	OSL_CLOSURE_BSDF_OREN_NAYAR_ID,
 	OSL_CLOSURE_BSDF_TRANSLUCENT_ID,
 	OSL_CLOSURE_BSDF_REFLECTION_ID,
 	OSL_CLOSURE_BSDF_REFRACTION_ID,
@@ -62,6 +63,7 @@ enum {
 };
 
 extern OSL::ClosureParam bsdf_diffuse_params[];
+extern OSL::ClosureParam bsdf_oren_nayar_params[];
 extern OSL::ClosureParam bsdf_translucent_params[];
 extern OSL::ClosureParam bsdf_reflection_params[];
 extern OSL::ClosureParam bsdf_refraction_params[];
@@ -82,6 +84,7 @@ extern OSL::ClosureParam closure_holdout_params[];
 extern OSL::ClosureParam closure_subsurface_params[];
 
 void bsdf_diffuse_prepare(OSL::RendererServices *, int id, void *data);
+void bsdf_oren_nayar_prepare(OSL::RendererServices *, int id, void *data);
 void bsdf_translucent_prepare(OSL::RendererServices *, int id, void *data);
 void bsdf_reflection_prepare(OSL::RendererServices *, int id, void *data);
 void bsdf_refraction_prepare(OSL::RendererServices *, int id, void *data);
diff --git a/intern/cycles/kernel/svm/bsdf_microfacet.h b/intern/cycles/kernel/svm/bsdf_microfacet.h
index 3acd3ba4c85..077b642c3c1 100644
--- a/intern/cycles/kernel/svm/bsdf_microfacet.h
+++ b/intern/cycles/kernel/svm/bsdf_microfacet.h
@@ -45,7 +45,7 @@ typedef struct BsdfMicrofacetGGXClosure {
 
 __device void bsdf_microfacet_ggx_setup(ShaderData *sd, ShaderClosure *sc, float ag, float eta, bool refractive)
 {
-	float m_ag = clamp(ag, 1e-5f, 1.0f);
+	float m_ag = clamp(ag, 1e-4f, 1.0f);
 	float m_eta = eta;
 
 	sc->data0 = m_ag;
@@ -270,7 +270,7 @@ typedef struct BsdfMicrofacetBeckmannClosure {
 
 __device void bsdf_microfacet_beckmann_setup(ShaderData *sd, ShaderClosure *sc, float ab, float eta, bool refractive)
 {
-	float m_ab = clamp(ab, 1e-5f, 1.0f);
+	float m_ab = clamp(ab, 1e-4f, 1.0f);
 	float m_eta = eta;
 
 	sc->data0 = m_ab;
diff --git a/intern/cycles/kernel/svm/bsdf_oren_nayar.h b/intern/cycles/kernel/svm/bsdf_oren_nayar.h
new file mode 100644
index 00000000000..0ad7cad06bb
--- /dev/null
+++ b/intern/cycles/kernel/svm/bsdf_oren_nayar.h
@@ -0,0 +1,145 @@
+/*
+ * Copyright 2011, Blender Foundation.
+ *
+ * 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.
+ */
+
+/*
+ *	An implementation of Oren-Nayar reflectance model, public domain
+ *		http://www1.cs.columbia.edu/CAVE/publications/pdfs/Oren_SIGGRAPH94.pdf
+ *
+ *	NOTE:
+ *		BSDF = A + B * cos() * sin() * tan()
+ *
+ *		The parameter sigma means different from original.
+ *		A and B are calculated by the following formula:
+ *			0 <= sigma <= 1
+ *			A =     1 / ((1 + sigma / 2) * pi);
+ *			B = sigma / ((1 + sigma / 2) * pi);
+ *
+ *		This formula is derived as following:
+ *
+ *		0. Normalize A-term and B-term of BSDF *individually*.
+ *		   B-term is normalized at maximum point: dot(L, N) = 0.
+ *			A = (1/pi) * A'
+ *			B = (2/pi) * B'
+ *
+ *		1. Solve the following equation:
+ *			A' + B' = 1
+ *			B / A = sigma
+ */
+
+#ifndef __BSDF_OREN_NAYAR_H__
+#define __BSDF_OREN_NAYAR_H__
+
+CCL_NAMESPACE_BEGIN
+
+typedef struct BsdfOrenNayarClosure {
+	float m_a;
+	float m_b;
+} BsdfOrenNayarClosure;
+
+__device float3 bsdf_oren_nayar_get_intensity(const ShaderClosure *sc, float3 n, float3 v, float3 l)
+{
+	float nl = max(dot(n, l), 0.0f);
+	float nv = max(dot(n, v), 0.0f);
+
+	float3 al = normalize(l - nl * n);
+	float3 av = normalize(v - nv * n);
+	float t = max(dot(al, av), 0.0f);
+
+	float cos_a, cos_b;
+	if(nl < nv) {
+		cos_a = nl;
+		cos_b = nv;
+	}
+	else {
+		cos_a = nv;
+		cos_b = nl;
+	}
+
+	float sin_a = sqrtf(max(1.0f - cos_a * cos_a, 0.0f));
+	float tan_b = sqrtf(max(1.0f - cos_b * cos_b, 0.0f)) / max(cos_b, 1e-8f);
+
+	float is = nl * (sc->data0 + sc->data1 * t * sin_a * tan_b);
+	return make_float3(is, is, is);
+}
+
+__device void bsdf_oren_nayar_setup(ShaderData *sd, ShaderClosure *sc, float sigma)
+{
+	sc->type = CLOSURE_BSDF_OREN_NAYAR_ID;
+	sd->flag |= SD_BSDF | SD_BSDF_HAS_EVAL;
+
+	sigma = clamp(sigma, 0.0f, 1.0f);
+
+	float div = 1.0f / ((1.0f + 0.5f * sigma) * M_PI_F);
+
+	sc->data0 =  1.0f * div;
+	sc->data1 = sigma * div;
+}
+
+__device void bsdf_oren_nayar_blur(ShaderClosure *sc, float roughness)
+{
+}
+
+__device float3 bsdf_oren_nayar_eval_reflect(const ShaderData *sd, const ShaderClosure *sc, const float3 I, const float3 omega_in, float *pdf)
+{
+	if (dot(sd->N, omega_in) > 0.0f) {
+		*pdf = 0.5f * M_1_PI_F;
+		return bsdf_oren_nayar_get_intensity(sc, sd->N, I, omega_in);
+	}
+	else {
+		*pdf = 0.0f;
+		return make_float3(0.0f, 0.0f, 0.0f);
+	}
+}
+
+__device float3 bsdf_oren_nayar_eval_transmit(const ShaderData *sd, const ShaderClosure *sc, const float3 I, const float3 omega_in, float *pdf)
+{
+	return make_float3(0.0f, 0.0f, 0.0f);
+}
+
+__device float bsdf_oren_nayar_albedo(const ShaderData *sd, const ShaderClosure *sc, const float3 I)
+{
+	return 1.0f;
+}
+
+__device int bsdf_oren_nayar_sample(const ShaderData *sd, const ShaderClosure *sc, float randu, float randv, float3 *eval, float3 *omega_in, float3 *domega_in_dx, float3 *domega_in_dy, float *pdf)
+{
+	sample_uniform_hemisphere(sd->N, randu, randv, omega_in, pdf);
+
+	if (dot(sd->Ng, *omega_in) > 0.0f) {
+		*eval = bsdf_oren_nayar_get_intensity(sc, sd->N, sd->I, *omega_in);
+
+#ifdef __RAY_DIFFERENTIALS__
+		// TODO: find a better approximation for the bounce
+		*domega_in_dx = (2.0f * dot(sd->N, sd->dI.dx)) * sd->N - sd->dI.dx;
+		*domega_in_dy = (2.0f * dot(sd->N, sd->dI.dy)) * sd->N - sd->dI.dy;
+		*domega_in_dx *= 125.0f;
+		*domega_in_dy *= 125.0f;
+#endif
+	}
+	else {
+		*pdf = 0.0f;
+		*eval = make_float3(0.0f, 0.0f, 0.0f);
+	}
+
+	return LABEL_REFLECT | LABEL_DIFFUSE;
+}
+
+
+CCL_NAMESPACE_END
+
+#endif /* __BSDF_OREN_NAYAR_H__ */
diff --git a/intern/cycles/kernel/svm/svm_bsdf.h b/intern/cycles/kernel/svm/svm_bsdf.h
index 411efc8be8f..411916f8aa0 100644
--- a/intern/cycles/kernel/svm/svm_bsdf.h
+++ b/intern/cycles/kernel/svm/svm_bsdf.h
@@ -18,6 +18,7 @@
 
 #include "bsdf_ashikhmin_velvet.h"
 #include "bsdf_diffuse.h"
+#include "bsdf_oren_nayar.h"
 #include "bsdf_microfacet.h"
 #include "bsdf_reflection.h"
 #include "bsdf_refraction.h"
@@ -38,6 +39,9 @@ __device int svm_bsdf_sample(const ShaderData *sd, const ShaderClosure *sc, floa
 			label = bsdf_diffuse_sample(sd, sc, randu, randv, eval, omega_in, &domega_in->dx, &domega_in->dy, pdf);
 			break;
 #ifdef __SVM__
+		case CLOSURE_BSDF_OREN_NAYAR_ID:
+			label = bsdf_oren_nayar_sample(sd, sc, randu, randv, eval, omega_in, &domega_in->dx, &domega_in->dy, pdf);
+			break;
 		case CLOSURE_BSDF_TRANSLUCENT_ID:
 			label = bsdf_translucent_sample(sd, sc, randu, randv, eval, omega_in, &domega_in->dx, &domega_in->dy, pdf);
 			break;
@@ -91,6 +95,9 @@ __device float3 svm_bsdf_eval(const ShaderData *sd, const ShaderClosure *sc, con
 				eval = bsdf_diffuse_eval_reflect(sd, sc, sd->I, omega_in, pdf);
 				break;
 #ifdef __SVM__
+			case CLOSURE_BSDF_OREN_NAYAR_ID:
+				eval = bsdf_oren_nayar_eval_reflect(sd, sc, sd->I, omega_in, pdf);
+				break;
 			case CLOSURE_BSDF_TRANSLUCENT_ID:
 				eval = bsdf_translucent_eval_reflect(sd, sc, sd->I, omega_in, pdf);
 				break;
@@ -137,6 +144,9 @@ __device float3 svm_bsdf_eval(const ShaderData *sd, const ShaderClosure *sc, con
 				eval = bsdf_diffuse_eval_transmit(sd, sc, sd->I, omega_in, pdf);
 				break;
 #ifdef __SVM__
+			case CLOSURE_BSDF_OREN_NAYAR_ID:
+				eval = bsdf_oren_nayar_eval_transmit(sd, sc, sd->I, omega_in, pdf);
+				break;
 			case CLOSURE_BSDF_TRANSLUCENT_ID:
 				eval = bsdf_translucent_eval_transmit(sd, sc, sd->I, omega_in, pdf);
 				break;
@@ -188,6 +198,9 @@ __device void svm_bsdf_blur(ShaderClosure *sc, float roughness)
 			bsdf_diffuse_blur(sc, roughness);
 			break;
 #ifdef __SVM__
+		case CLOSURE_BSDF_OREN_NAYAR_ID:
+			bsdf_oren_nayar_blur(sc, roughness);
+			break;
 		case CLOSURE_BSDF_TRANSLUCENT_ID:
 			bsdf_translucent_blur(sc, roughness);
 			break;
diff --git a/intern/cycles/kernel/svm/svm_closure.h b/intern/cycles/kernel/svm/svm_closure.h
index fcda7ac6fe1..8409e83d94e 100644
--- a/intern/cycles/kernel/svm/svm_closure.h
+++ b/intern/cycles/kernel/svm/svm_closure.h
@@ -80,7 +80,12 @@ __device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *st
 		case CLOSURE_BSDF_DIFFUSE_ID: {
 			ShaderClosure *sc = svm_node_closure_get(sd);
 			svm_node_closure_set_mix_weight(sc, mix_weight);
-			bsdf_diffuse_setup(sd, sc);
+
+			float roughness = param1;
+			if(roughness == 0.0f)
+				bsdf_diffuse_setup(sd, sc);
+			else
+				bsdf_oren_nayar_setup(sd, sc, roughness);
 			break;
 		}
 		case CLOSURE_BSDF_TRANSLUCENT_ID: {
diff --git a/intern/cycles/kernel/svm/svm_types.h b/intern/cycles/kernel/svm/svm_types.h
index 89fc413c539..071477a83c7 100644
--- a/intern/cycles/kernel/svm/svm_types.h
+++ b/intern/cycles/kernel/svm/svm_types.h
@@ -258,6 +258,7 @@ typedef enum ShaderType {
 typedef enum ClosureType {
 	CLOSURE_BSDF_ID,
 	CLOSURE_BSDF_DIFFUSE_ID,
+	CLOSURE_BSDF_OREN_NAYAR_ID,
 	CLOSURE_BSDF_TRANSLUCENT_ID,
 	CLOSURE_BSDF_REFLECTION_ID,
 	CLOSURE_BSDF_REFRACTION_ID,
diff --git a/intern/cycles/render/nodes.cpp b/intern/cycles/render/nodes.cpp
index f934b703103..d7bd74c9ec7 100644
--- a/intern/cycles/render/nodes.cpp
+++ b/intern/cycles/render/nodes.cpp
@@ -1003,11 +1003,12 @@ void VelvetBsdfNode::compile(OSLCompiler& compiler)
 DiffuseBsdfNode::DiffuseBsdfNode()
 {
 	closure = CLOSURE_BSDF_DIFFUSE_ID;
+	add_input("Roughness", SHADER_SOCKET_FLOAT, 0.0f);
 }
 
 void DiffuseBsdfNode::compile(SVMCompiler& compiler)
 {
-	BsdfNode::compile(compiler, NULL, NULL);
+	BsdfNode::compile(compiler, input("Roughness"), NULL);
 }
 
 void DiffuseBsdfNode::compile(OSLCompiler& compiler)
diff --git a/intern/cycles/util/CMakeLists.txt b/intern/cycles/util/CMakeLists.txt
index 76e948504eb..9182ee4cbe1 100644
--- a/intern/cycles/util/CMakeLists.txt
+++ b/intern/cycles/util/CMakeLists.txt
@@ -11,7 +11,7 @@ set(SRC
 	util_dynlib.cpp
 	util_md5.cpp
 	util_memarena.cpp
-	util_opencl.c
+	util_opencl.cpp
 	util_path.cpp
 	util_string.cpp
 	util_system.cpp
diff --git a/intern/cycles/util/util_opencl.c b/intern/cycles/util/util_opencl.cpp
index 10429ffcd80..1d05b0b687a 100755..100644
--- a/intern/cycles/util/util_opencl.c
+++ b/intern/cycles/util/util_opencl.cpp
@@ -7,6 +7,8 @@
 //  Extracted from the CLCC project - http://clcc.sourceforge.net/
 //////////////////////////////////////////////////////////////////////////
 
+#include <stdlib.h>
+
 #include "util_opencl.h"
 
 #ifndef CLCC_GENERATE_DOCUMENTATION
@@ -36,7 +38,7 @@
     //#define CLCC_DYNLIB_IMPORT      implementation_defined
 #endif
 
-#include <stdlib.h>
+CCL_NAMESPACE_BEGIN
 
 //! \brief module handle
 static CLCC_DYNLIB_HANDLE module = NULL;
@@ -315,3 +317,5 @@ const char *clErrorString(cl_int error)
     return strings[-error];
 }
 
+CCL_NAMESPACE_END
+
diff --git a/intern/cycles/util/util_opencl.h b/intern/cycles/util/util_opencl.h
index 08694874ac1..2e97097ef36 100755..100644
--- a/intern/cycles/util/util_opencl.h
+++ b/intern/cycles/util/util_opencl.h
@@ -10,6 +10,8 @@
 #ifndef __UTIL_OPENCL_H__
 #define __UTIL_OPENCL_H__
 
+CCL_NAMESPACE_BEGIN
+
 //! This file contains a copy of the contents of CL.H and CL_PLATFORM.H from the 
 //! official OpenCL spec. The purpose of this code is to load the OpenCL dynamic
 //! library at run-time and thus allow the executable to function on many
@@ -56,15 +58,6 @@
 * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
 ******************************************************************************/
 
-#ifdef __APPLE__
-/* Contains #defines for AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER below */
-#include <AvailabilityMacros.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #ifndef CLCC_GENERATE_DOCUMENTATION
 
 #if defined(_WIN32)
@@ -1312,9 +1305,7 @@ CLEW_FUN_EXPORT     PFNCLGETEXTENSIONFUNCTIONADDRESS    __clewGetExtensionFuncti
 int clLibraryInit(void);
 const char *clErrorString(cl_int error);
 
-#ifdef __cplusplus
-}
-#endif
+CCL_NAMESPACE_END
 
 #endif /*  __UTIL_OPENCL_H__ */
 
diff --git a/intern/cycles/util/util_system.cpp b/intern/cycles/util/util_system.cpp
index 8b09f227a74..abf5e08de97 100644
--- a/intern/cycles/util/util_system.cpp
+++ b/intern/cycles/util/util_system.cpp
@@ -118,5 +118,78 @@ int system_cpu_bits()
 	return (sizeof(void*)*8);
 }
 
+#if defined(__x86_64__) || defined(_M_X64) || defined(i386) || defined(_M_IX86)
+
+struct CPUCapabilities {
+	bool x64;
+	bool mmx;
+	bool sse;
+	bool sse2;
+	bool sse3;
+	bool ssse3;
+	bool sse41;
+	bool sse42;
+	bool sse4a;
+	bool avx;
+	bool xop;
+	bool fma3;
+	bool fma4;
+};
+
+bool system_cpu_support_optimized()
+{
+	static CPUCapabilities caps;
+	static bool caps_init = false;
+
+	if(!caps_init) {
+		int result[4], num, num_ex;
+
+		memset(&caps, 0, sizeof(caps));
+
+		__cpuid(result, 0);
+		num = result[0];
+
+		__cpuid(result, 0x80000000);
+		num_ex = result[0];
+
+		if(num >= 1){
+			__cpuid(result, 0x00000001);
+			caps.mmx = (result[3] & ((int)1 << 23)) != 0;
+			caps.sse = (result[3] & ((int)1 << 25)) != 0;
+			caps.sse2 = (result[3] & ((int)1 << 26)) != 0;
+			caps.sse3 = (result[2] & ((int)1 <<  0)) != 0;
+
+			caps.ssse3 = (result[2] & ((int)1 <<  9)) != 0;
+			caps.sse41 = (result[2] & ((int)1 << 19)) != 0;
+			caps.sse42 = (result[2] & ((int)1 << 20)) != 0;
+
+			caps.avx = (result[2] & ((int)1 << 28)) != 0;
+			caps.fma3 = (result[2] & ((int)1 << 12)) != 0;
+		}
+
+		/*if(num_ex >= 0x80000001){
+			__cpuid(result, 0x80000001);
+			caps.x64 = (result[3] & ((int)1 << 29)) != 0;
+			caps.sse4a = (result[2] & ((int)1 <<  6)) != 0;
+			caps.fma4 = (result[2] & ((int)1 << 16)) != 0;
+			caps.xop = (result[2] & ((int)1 << 11)) != 0;
+		}*/
+
+		caps_init = true;
+	}
+
+	/* optimization flags use these */
+	return caps.sse && caps.sse2 && caps.sse3;
+}
+
+#else
+
+bool system_cpu_support_optimized()
+{
+	return false;
+}
+
+#endif
+
 CCL_NAMESPACE_END
 
diff --git a/intern/cycles/util/util_system.h b/intern/cycles/util/util_system.h
index 214b3a18ca3..f25e009a250 100644
--- a/intern/cycles/util/util_system.h
+++ b/intern/cycles/util/util_system.h
@@ -26,6 +26,7 @@ CCL_NAMESPACE_BEGIN
 int system_cpu_thread_count();
 string system_cpu_brand_string();
 int system_cpu_bits();
+bool system_cpu_support_optimized();
 
 CCL_NAMESPACE_END