Merge branch 'master' into blender2.8

Conflicts:
	source/blender/editors/space_action/action_draw.c

84 files changed, 3211 insertions, 1311 deletions

diff --git a/doc/python_api/sphinx_doc_gen.py b/doc/python_api/sphinx_doc_gen.py
index 3cb98c677c1..e8154f9ea66 100644
--- a/doc/python_api/sphinx_doc_gen.py
+++ b/doc/python_api/sphinx_doc_gen.py
@@ -1655,6 +1655,7 @@ def write_sphinx_conf_py(basepath):
 
     # not helpful since the source is generated, adds to upload size.
     fw("html_copy_source = False\n")
+    fw("html_show_sphinx = False\n")
     fw("html_split_index = True\n")
     fw("\n")
 
diff --git a/intern/cycles/CMakeLists.txt b/intern/cycles/CMakeLists.txt
index 97854a88e84..79c1c3e3e82 100644
--- a/intern/cycles/CMakeLists.txt
+++ b/intern/cycles/CMakeLists.txt
@@ -74,7 +74,6 @@ elseif(CMAKE_COMPILER_IS_GNUCC)
 	if(CXX_HAS_AVX2)
 		set(CYCLES_AVX2_KERNEL_FLAGS "-ffast-math -msse -msse2 -msse3 -mssse3 -msse4.1 -mavx -mavx2 -mfma -mlzcnt -mbmi -mbmi2 -mf16c -mfpmath=sse")
 	endif()
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffast-math")
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 	check_cxx_compiler_flag(-msse CXX_HAS_SSE)
 	check_cxx_compiler_flag(-mavx CXX_HAS_AVX)
@@ -90,7 +89,6 @@ elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 	if(CXX_HAS_AVX2)
 		set(CYCLES_AVX2_KERNEL_FLAGS "-ffast-math -msse -msse2 -msse3 -mssse3 -msse4.1 -mavx -mavx2 -mfma -mlzcnt -mbmi -mbmi2 -mf16c")
 	endif()
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffast-math")
 endif()
 
 if(CXX_HAS_SSE)
diff --git a/intern/cycles/blender/addon/__init__.py b/intern/cycles/blender/addon/__init__.py
index 29388317873..1fc3758ad4d 100644
--- a/intern/cycles/blender/addon/__init__.py
+++ b/intern/cycles/blender/addon/__init__.py
@@ -28,6 +28,20 @@ bl_info = {
     "support": 'OFFICIAL',
     "category": "Render"}
 
+# Support 'reload' case.
+if "bpy" in locals():
+    import importlib
+    if "engine" in locals():
+        importlib.reload(engine)
+    if "version_update" in locals():
+        importlib.reload(version_update)
+    if "ui" in locals():
+        importlib.reload(ui)
+    if "properties" in locals():
+        importlib.reload(properties)
+    if "presets" in locals():
+        importlib.reload(presets)
+
 import bpy
 
 from . import (
diff --git a/intern/cycles/blender/addon/properties.py b/intern/cycles/blender/addon/properties.py
index 3616b13e751..802b9b76c5d 100644
--- a/intern/cycles/blender/addon/properties.py
+++ b/intern/cycles/blender/addon/properties.py
@@ -528,6 +528,12 @@ class CyclesRenderSettings(bpy.types.PropertyGroup):
                 description="Use special type BVH optimized for hair (uses more ram but renders faster)",
                 default=True,
                 )
+        cls.debug_bvh_time_steps = IntProperty(
+                name="BVH Time Steps",
+                description="Split BVH primitives by this number of time steps to speed up render time in cost of memory",
+                default=0,
+                min=0, max=16,
+                )
         cls.tile_order = EnumProperty(
                 name="Tile Order",
                 description="Tile order for rendering",
diff --git a/intern/cycles/blender/addon/ui.py b/intern/cycles/blender/addon/ui.py
index a573fa1ce22..7a59698e15e 100644
--- a/intern/cycles/blender/addon/ui.py
+++ b/intern/cycles/blender/addon/ui.py
@@ -432,6 +432,10 @@ class CyclesRender_PT_performance(CyclesButtonsPanel, Panel):
         col.prop(cscene, "debug_use_spatial_splits")
         col.prop(cscene, "debug_use_hair_bvh")
 
+        row = col.row()
+        row.active = not cscene.debug_use_spatial_splits
+        row.prop(cscene, "debug_bvh_time_steps")
+
 
 class CyclesRender_PT_layer_options(CyclesButtonsPanel, Panel):
     bl_label = "Layer"
@@ -787,10 +791,13 @@ class CyclesObject_PT_cycles_settings(CyclesButtonsPanel, Panel):
         col = layout.column()
         col.label(text="Performance:")
         row = col.row()
-        row.active = scene.render.use_simplify and cscene.use_camera_cull
-        row.prop(cob, "use_camera_cull")
-        row.active = scene.render.use_simplify and cscene.use_distance_cull
-        row.prop(cob, "use_distance_cull")
+        sub = row.row()
+        sub.active = scene.render.use_simplify and cscene.use_camera_cull
+        sub.prop(cob, "use_camera_cull")
+
+        sub = row.row()
+        sub.active = scene.render.use_simplify and cscene.use_distance_cull
+        sub.prop(cob, "use_distance_cull")
 
 
 class CYCLES_OT_use_shading_nodes(Operator):
diff --git a/intern/cycles/blender/blender_sync.cpp b/intern/cycles/blender/blender_sync.cpp
index 38b2ce19e8a..f8f2303ec76 100644
--- a/intern/cycles/blender/blender_sync.cpp
+++ b/intern/cycles/blender/blender_sync.cpp
@@ -498,6 +498,7 @@ SceneParams BlenderSync::get_scene_params(BL::Scene& b_scene,
 
 	params.use_bvh_spatial_split = RNA_boolean_get(&cscene, "debug_use_spatial_splits");
 	params.use_bvh_unaligned_nodes = RNA_boolean_get(&cscene, "debug_use_hair_bvh");
+	params.num_bvh_time_steps = RNA_int_get(&cscene, "debug_bvh_time_steps");
 
 	if(background && params.shadingsystem != SHADINGSYSTEM_OSL)
 		params.persistent_data = r.use_persistent_data();
diff --git a/intern/cycles/bvh/bvh.cpp b/intern/cycles/bvh/bvh.cpp
index 4851de5b481..874a4246d1d 100644
--- a/intern/cycles/bvh/bvh.cpp
+++ b/intern/cycles/bvh/bvh.cpp
@@ -845,6 +845,8 @@ void QBVH::pack_aligned_inner(const BVHStackEntry& e,
 	                  bounds,
 	                  child,
 	                  e.node->m_visibility,
+	                  e.node->m_time_from,
+	                  e.node->m_time_to,
 	                  num);
 }
 
@@ -852,12 +854,17 @@ void QBVH::pack_aligned_node(int idx,
                              const BoundBox *bounds,
                              const int *child,
                              const uint visibility,
+                             const float time_from,
+                             const float time_to,
                              const int num)
 {
 	float4 data[BVH_QNODE_SIZE];
 	memset(data, 0, sizeof(data));
 
 	data[0].x = __uint_as_float(visibility & ~PATH_RAY_NODE_UNALIGNED);
+	data[0].y = time_from;
+	data[0].z = time_to;
+
 	for(int i = 0; i < num; i++) {
 		float3 bb_min = bounds[i].min;
 		float3 bb_max = bounds[i].max;
@@ -908,6 +915,8 @@ void QBVH::pack_unaligned_inner(const BVHStackEntry& e,
 	                    bounds,
 	                    child,
 	                    e.node->m_visibility,
+	                    e.node->m_time_from,
+	                    e.node->m_time_to,
 	                    num);
 }
 
@@ -916,12 +925,16 @@ void QBVH::pack_unaligned_node(int idx,
                                const BoundBox *bounds,
                                const int *child,
                                const uint visibility,
+                               const float time_from,
+                               const float time_to,
                                const int num)
 {
 	float4 data[BVH_UNALIGNED_QNODE_SIZE];
 	memset(data, 0, sizeof(data));
 
 	data[0].x = __uint_as_float(visibility | PATH_RAY_NODE_UNALIGNED);
+	data[0].y = time_from;
+	data[0].z = time_to;
 
 	for(int i = 0; i < num; i++) {
 		Transform space = BVHUnaligned::compute_node_transform(
@@ -1207,6 +1220,8 @@ void QBVH::refit_node(int idx, bool leaf, BoundBox& bbox, uint& visibility)
 			                    child_bbox,
 			                    &c[0],
 			                    visibility,
+			                    0.0f,
+			                    1.0f,
 			                    4);
 		}
 		else {
@@ -1214,6 +1229,8 @@ void QBVH::refit_node(int idx, bool leaf, BoundBox& bbox, uint& visibility)
 			                  child_bbox,
 			                  &c[0],
 			                  visibility,
+			                  0.0f,
+			                  1.0f,
 			                  4);
 		}
 	}
diff --git a/intern/cycles/bvh/bvh.h b/intern/cycles/bvh/bvh.h
index f8fb3b568ca..35f4d305883 100644
--- a/intern/cycles/bvh/bvh.h
+++ b/intern/cycles/bvh/bvh.h
@@ -175,6 +175,8 @@ protected:
 	                       const BoundBox *bounds,
 	                       const int *child,
 	                       const uint visibility,
+	                       const float time_from,
+	                       const float time_to,
 	                       const int num);
 
 	void pack_unaligned_inner(const BVHStackEntry& e,
@@ -185,6 +187,8 @@ protected:
 	                         const BoundBox *bounds,
 	                         const int *child,
 	                         const uint visibility,
+	                         const float time_from,
+	                         const float time_to,
 	                         const int num);
 
 	/* refit */
diff --git a/intern/cycles/bvh/bvh_build.cpp b/intern/cycles/bvh/bvh_build.cpp
index 8cf1495b33d..1ce3a754460 100644
--- a/intern/cycles/bvh/bvh_build.cpp
+++ b/intern/cycles/bvh/bvh_build.cpp
@@ -112,84 +112,237 @@ BVHBuild::~BVHBuild()
 
 /* Adding References */
 
-void BVHBuild::add_reference_mesh(BoundBox& root, BoundBox& center, Mesh *mesh, int i)
+void BVHBuild::add_reference_triangles(BoundBox& root, BoundBox& center, Mesh *mesh, int i)
 {
-	if(params.primitive_mask & PRIMITIVE_ALL_TRIANGLE) {
-		Attribute *attr_mP = NULL;
-
-		if(mesh->has_motion_blur())
-			attr_mP = mesh->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
-
-		size_t num_triangles = mesh->num_triangles();
-		for(uint j = 0; j < num_triangles; j++) {
-			Mesh::Triangle t = mesh->get_triangle(j);
+	const Attribute *attr_mP = NULL;
+	if(mesh->has_motion_blur()) {
+		attr_mP = mesh->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
+	}
+	const size_t num_triangles = mesh->num_triangles();
+	for(uint j = 0; j < num_triangles; j++) {
+		Mesh::Triangle t = mesh->get_triangle(j);
+		const float3 *verts = &mesh->verts[0];
+		if(attr_mP == NULL) {
 			BoundBox bounds = BoundBox::empty;
-			PrimitiveType type = PRIMITIVE_TRIANGLE;
-
-			t.bounds_grow(&mesh->verts[0], bounds);
-
-			/* motion triangles */
-			if(attr_mP) {
-				const size_t mesh_size = mesh->verts.size();
-				const size_t num_steps = mesh->motion_steps - 1;
-				const float3 *vert_steps = attr_mP->data_float3();
-
-				for(size_t step = 0; step < num_steps; step++) {
-					t.bounds_grow(vert_steps + step*mesh_size, bounds);
-				}
-
-				type = PRIMITIVE_MOTION_TRIANGLE;
+			t.bounds_grow(verts, bounds);
+			if(bounds.valid()) {
+				references.push_back(BVHReference(bounds,
+				                                  j,
+				                                  i,
+				                                  PRIMITIVE_TRIANGLE));
+				root.grow(bounds);
+				center.grow(bounds.center2());
+			}
+		}
+		else if(params.num_motion_triangle_steps == 0 || params.use_spatial_split) {
+			/* Motion triangles, simple case: single node for the whole
+			 * primitive. Lowest memory footprint and faster BVH build but
+			 * least optimal ray-tracing.
+			 */
+			/* TODO(sergey): Support motion steps for spatially split BVH. */
+			const size_t num_verts = mesh->verts.size();
+			const size_t num_steps = mesh->motion_steps;
+			const float3 *vert_steps = attr_mP->data_float3();
+			BoundBox bounds = BoundBox::empty;
+			t.bounds_grow(verts, bounds);
+			for(size_t step = 0; step < num_steps - 1; step++) {
+				t.bounds_grow(vert_steps + step*num_verts, bounds);
 			}
-
 			if(bounds.valid()) {
-				references.push_back(BVHReference(bounds, j, i, type));
+				references.push_back(
+				        BVHReference(bounds,
+				                     j,
+				                     i,
+				                     PRIMITIVE_MOTION_TRIANGLE));
 				root.grow(bounds);
 				center.grow(bounds.center2());
 			}
 		}
+		else {
+			/* Motion triangles, trace optimized case:  we split triangle
+			 * primitives into separate nodes for each of the time steps.
+			 * This way we minimize overlap of neighbor curve primitives.
+			 */
+			const int num_bvh_steps = params.num_motion_curve_steps * 2 + 1;
+			const float num_bvh_steps_inv_1 = 1.0f / (num_bvh_steps - 1);
+			const size_t num_verts = mesh->verts.size();
+			const size_t num_steps = mesh->motion_steps;
+			const float3 *vert_steps = attr_mP->data_float3();
+			/* Calculate bounding box of the previous time step.
+			 * Will be reused later to avoid duplicated work on
+			 * calculating BVH time step boundbox.
+			 */
+			float3 prev_verts[3];
+			t.motion_verts(verts,
+			               vert_steps,
+			               num_verts,
+			               num_steps,
+			               0.0f,
+			               prev_verts);
+			BoundBox prev_bounds = BoundBox::empty;
+			prev_bounds.grow(prev_verts[0]);
+			prev_bounds.grow(prev_verts[1]);
+			prev_bounds.grow(prev_verts[2]);
+			/* Create all primitive time steps, */
+			for(int bvh_step = 1; bvh_step < num_bvh_steps; ++bvh_step) {
+				const float curr_time = (float)(bvh_step) * num_bvh_steps_inv_1;
+				float3 curr_verts[3];
+				t.motion_verts(verts,
+				               vert_steps,
+				               num_verts,
+				               num_steps,
+				               curr_time,
+				               curr_verts);
+				BoundBox curr_bounds = BoundBox::empty;
+				curr_bounds.grow(curr_verts[0]);
+				curr_bounds.grow(curr_verts[1]);
+				curr_bounds.grow(curr_verts[2]);
+				BoundBox bounds = prev_bounds;
+				bounds.grow(curr_bounds);
+				if(bounds.valid()) {
+					const float prev_time = (float)(bvh_step - 1) * num_bvh_steps_inv_1;
+					references.push_back(
+					        BVHReference(bounds,
+					                     j,
+					                     i,
+					                     PRIMITIVE_MOTION_TRIANGLE,
+					                     prev_time,
+					                     curr_time));
+					root.grow(bounds);
+					center.grow(bounds.center2());
+				}
+				/* Current time boundbox becomes previous one for the
+				 * next time step.
+				 */
+				prev_bounds = curr_bounds;
+			}
+		}
 	}
+}
 
-	if(params.primitive_mask & PRIMITIVE_ALL_CURVE) {
-		Attribute *curve_attr_mP = NULL;
-
-		if(mesh->has_motion_blur())
-			curve_attr_mP = mesh->curve_attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
-
-		size_t num_curves = mesh->num_curves();
-		for(uint j = 0; j < num_curves; j++) {
-			const Mesh::Curve curve = mesh->get_curve(j);
-			PrimitiveType type = PRIMITIVE_CURVE;
-			const float *curve_radius = &mesh->curve_radius[0];
-
-			for(int k = 0; k < curve.num_keys - 1; k++) {
+void BVHBuild::add_reference_curves(BoundBox& root, BoundBox& center, Mesh *mesh, int i)
+{
+	const Attribute *curve_attr_mP = NULL;
+	if(mesh->has_motion_blur()) {
+		curve_attr_mP = mesh->curve_attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
+	}
+	const size_t num_curves = mesh->num_curves();
+	for(uint j = 0; j < num_curves; j++) {
+		const Mesh::Curve curve = mesh->get_curve(j);
+		const float *curve_radius = &mesh->curve_radius[0];
+		for(int k = 0; k < curve.num_keys - 1; k++) {
+			if(curve_attr_mP == NULL) {
+				/* Really simple logic for static hair. */
 				BoundBox bounds = BoundBox::empty;
 				curve.bounds_grow(k, &mesh->curve_keys[0], curve_radius, bounds);
-
-				/* motion curve */
-				if(curve_attr_mP) {
-					const size_t mesh_size = mesh->curve_keys.size();
-					const size_t num_steps = mesh->motion_steps - 1;
-					const float3 *key_steps = curve_attr_mP->data_float3();
-
-					for(size_t step = 0; step < num_steps; step++) {
-						curve.bounds_grow(k, key_steps + step*mesh_size, curve_radius, bounds);
-					}
-
-					type = PRIMITIVE_MOTION_CURVE;
-				}
-
 				if(bounds.valid()) {
-					int packed_type = PRIMITIVE_PACK_SEGMENT(type, k);
-
+					int packed_type = PRIMITIVE_PACK_SEGMENT(PRIMITIVE_CURVE, k);
 					references.push_back(BVHReference(bounds, j, i, packed_type));
 					root.grow(bounds);
 					center.grow(bounds.center2());
 				}
 			}
+			else if(params.num_motion_curve_steps == 0 || params.use_spatial_split) {
+				/* Simple case of motion curves: single node for the while
+				 * shutter time. Lowest memory usage but less optimal
+				 * rendering.
+				 */
+				/* TODO(sergey): Support motion steps for spatially split BVH. */
+				BoundBox bounds = BoundBox::empty;
+				curve.bounds_grow(k, &mesh->curve_keys[0], curve_radius, bounds);
+				const size_t num_keys = mesh->curve_keys.size();
+				const size_t num_steps = mesh->motion_steps;
+				const float3 *key_steps = curve_attr_mP->data_float3();
+				for(size_t step = 0; step < num_steps - 1; step++) {
+					curve.bounds_grow(k,
+					                  key_steps + step*num_keys,
+					                  curve_radius,
+					                  bounds);
+				}
+				if(bounds.valid()) {
+					int packed_type = PRIMITIVE_PACK_SEGMENT(PRIMITIVE_MOTION_CURVE, k);
+					references.push_back(BVHReference(bounds,
+					                                  j,
+					                                  i,
+					                                  packed_type));
+					root.grow(bounds);
+					center.grow(bounds.center2());
+				}
+			}
+			else {
+				/* Motion curves, trace optimized case:  we split curve keys
+				 * primitives into separate nodes for each of the time steps.
+				 * This way we minimize overlap of neighbor curve primitives.
+				 */
+				const int num_bvh_steps = params.num_motion_curve_steps * 2 + 1;
+				const float num_bvh_steps_inv_1 = 1.0f / (num_bvh_steps - 1);
+				const size_t num_steps = mesh->motion_steps;
+				const float3 *curve_keys = &mesh->curve_keys[0];
+				const float3 *key_steps = curve_attr_mP->data_float3();
+				const size_t num_keys = mesh->curve_keys.size();
+				/* Calculate bounding box of the previous time step.
+				 * Will be reused later to avoid duplicated work on
+				 * calculating BVH time step boundbox.
+				 */
+				float4 prev_keys[4];
+				curve.cardinal_motion_keys(curve_keys,
+				                           curve_radius,
+				                           key_steps,
+				                           num_keys,
+				                           num_steps,
+				                           0.0f,
+				                           k - 1, k, k + 1, k + 2,
+				                           prev_keys);
+				BoundBox prev_bounds = BoundBox::empty;
+				curve.bounds_grow(prev_keys, prev_bounds);
+				/* Create all primitive time steps, */
+				for(int bvh_step = 1; bvh_step < num_bvh_steps; ++bvh_step) {
+					const float curr_time = (float)(bvh_step) * num_bvh_steps_inv_1;
+					float4 curr_keys[4];
+					curve.cardinal_motion_keys(curve_keys,
+					                           curve_radius,
+					                           key_steps,
+					                           num_keys,
+					                           num_steps,
+					                           curr_time,
+					                           k - 1, k, k + 1, k + 2,
+					                           curr_keys);
+					BoundBox curr_bounds = BoundBox::empty;
+					curve.bounds_grow(curr_keys, curr_bounds);
+					BoundBox bounds = prev_bounds;
+					bounds.grow(curr_bounds);
+					if(bounds.valid()) {
+						const float prev_time = (float)(bvh_step - 1) * num_bvh_steps_inv_1;
+						int packed_type = PRIMITIVE_PACK_SEGMENT(PRIMITIVE_MOTION_CURVE, k);
+						references.push_back(BVHReference(bounds,
+						                                  j,
+						                                  i,
+						                                  packed_type,
+						                                  prev_time,
+						                                  curr_time));
+						root.grow(bounds);
+						center.grow(bounds.center2());
+					}
+					/* Current time boundbox becomes previous one for the
+					 * next time step.
+					 */
+					prev_bounds = curr_bounds;
+				}
+			}
 		}
 	}
 }
 
+void BVHBuild::add_reference_mesh(BoundBox& root, BoundBox& center, Mesh *mesh, int i)
+{
+	if(params.primitive_mask & PRIMITIVE_ALL_TRIANGLE) {
+		add_reference_triangles(root, center, mesh, i);
+	}
+	if(params.primitive_mask & PRIMITIVE_ALL_CURVE) {
+		add_reference_curves(root, center, mesh, i);
+	}
+}
+
 void BVHBuild::add_reference_object(BoundBox& root, BoundBox& center, Object *ob, int i)
 {
 	references.push_back(BVHReference(ob->bounds, -1, i, 0));
@@ -203,7 +356,7 @@ static size_t count_curve_segments(Mesh *mesh)
 
 	for(size_t i = 0; i < num_curves; i++)
 		num += mesh->get_curve(i).num_keys - 1;
-	
+
 	return num;
 }
 
@@ -347,6 +500,7 @@ BVHNode* BVHBuild::run()
 		else {
 			/*rotate(rootnode, 4, 5);*/
 			rootnode->update_visibility();
+			rootnode->update_time();
 		}
 		if(rootnode != NULL) {
 			VLOG(1) << "BVH build statistics:\n"
@@ -374,7 +528,7 @@ void BVHBuild::progress_update()
 {
 	if(time_dt() - progress_start_time < 0.25)
 		return;
-	
+
 	double progress_start = (double)progress_count/(double)progress_total;
 	double duplicates = (double)(progress_total - progress_original_total)/(double)progress_total;
 
@@ -382,7 +536,7 @@ void BVHBuild::progress_update()
 	                           progress_start * 100.0, duplicates * 100.0);
 
 	progress.set_substatus(msg);
-	progress_start_time = time_dt(); 
+	progress_start_time = time_dt();
 }
 
 void BVHBuild::thread_build_node(InnerNode *inner,
@@ -696,18 +850,24 @@ BVHNode *BVHBuild::create_object_leaf_nodes(const BVHReference *ref, int start,
 		prim_object[start] = ref->prim_object();
 
 		uint visibility = objects[ref->prim_object()]->visibility;
-		return new LeafNode(ref->bounds(), visibility, start, start+1);
+		BVHNode *leaf_node =  new LeafNode(ref->bounds(), visibility, start, start+1);
+		leaf_node->m_time_from = ref->time_from();
+		leaf_node->m_time_to = ref->time_to();
+		return leaf_node;
 	}
 	else {
 		int mid = num/2;
-		BVHNode *leaf0 = create_object_leaf_nodes(ref, start, mid); 
-		BVHNode *leaf1 = create_object_leaf_nodes(ref+mid, start+mid, num-mid); 
+		BVHNode *leaf0 = create_object_leaf_nodes(ref, start, mid);
+		BVHNode *leaf1 = create_object_leaf_nodes(ref+mid, start+mid, num-mid);
 
 		BoundBox bounds = BoundBox::empty;
 		bounds.grow(leaf0->m_bounds);
 		bounds.grow(leaf1->m_bounds);
 
-		return new InnerNode(bounds, leaf0, leaf1);
+		BVHNode *inner_node = new InnerNode(bounds, leaf0, leaf1);
+		inner_node->m_time_from = min(leaf0->m_time_from, leaf1->m_time_from);
+		inner_node->m_time_to = max(leaf0->m_time_to, leaf1->m_time_to);
+		return inner_node;
 	}
 }
 
@@ -811,6 +971,16 @@ BVHNode* BVHBuild::create_leaf_node(const BVHRange& range,
 			                                   visibility[i],
 			                                   start_index,
 			                                   start_index + num);
+			if(true) {
+				float time_from = 1.0f, time_to = 0.0f;
+				for(int j = 0; j < num; ++j) {
+					const BVHReference &ref = p_ref[i][j];
+					time_from = min(time_from, ref.time_from());
+					time_to = max(time_to, ref.time_to());
+				}
+				leaf_node->m_time_from = time_from;
+				leaf_node->m_time_to = time_to;
+			}
 			if(alignment_found) {
 				/* Need to recalculate leaf bounds with new alignment. */
 				leaf_node->m_bounds = BoundBox::empty;
@@ -958,7 +1128,7 @@ void BVHBuild::rotate(BVHNode *node, int max_depth)
 	/* nothing to rotate if we reached a leaf node. */
 	if(node->is_leaf() || max_depth < 0)
 		return;
-	
+
 	InnerNode *parent = (InnerNode*)node;
 
 	/* rotate all children first */
diff --git a/intern/cycles/bvh/bvh_build.h b/intern/cycles/bvh/bvh_build.h
index 64180349935..ee3cde66a2f 100644
--- a/intern/cycles/bvh/bvh_build.h
+++ b/intern/cycles/bvh/bvh_build.h
@@ -63,6 +63,8 @@ protected:
 	friend class BVHObjectBinning;
 
 	/* Adding references. */
+	void add_reference_triangles(BoundBox& root, BoundBox& center, Mesh *mesh, int i);
+	void add_reference_curves(BoundBox& root, BoundBox& center, Mesh *mesh, int i);
 	void add_reference_mesh(BoundBox& root, BoundBox& center, Mesh *mesh, int i);
 	void add_reference_object(BoundBox& root, BoundBox& center, Object *ob, int i);
 	void add_references(BVHRange& root);
diff --git a/intern/cycles/bvh/bvh_node.cpp b/intern/cycles/bvh/bvh_node.cpp
index f5cd699bdf4..67580e1bc7b 100644
--- a/intern/cycles/bvh/bvh_node.cpp
+++ b/intern/cycles/bvh/bvh_node.cpp
@@ -176,6 +176,19 @@ uint BVHNode::update_visibility()
 	return m_visibility;
 }
 
+void BVHNode::update_time()
+{
+	if(!is_leaf()) {
+		InnerNode *inner = (InnerNode*)this;
+		BVHNode *child0 = inner->children[0];
+		BVHNode *child1 = inner->children[1];
+		child0->update_time();
+		child1->update_time();
+		m_time_from = min(child0->m_time_from, child1->m_time_from);
+		m_time_to =  max(child0->m_time_to, child1->m_time_to);
+	}
+}
+
 /* Inner Node */
 
 void InnerNode::print(int depth) const
diff --git a/intern/cycles/bvh/bvh_node.h b/intern/cycles/bvh/bvh_node.h
index 2faa40ab657..090c426de56 100644
--- a/intern/cycles/bvh/bvh_node.h
+++ b/intern/cycles/bvh/bvh_node.h
@@ -47,7 +47,9 @@ class BVHNode
 {
 public:
 	BVHNode() : m_is_unaligned(false),
-	            m_aligned_space(NULL)
+	            m_aligned_space(NULL),
+	            m_time_from(0.0f),
+	            m_time_to(1.0f)
 	{
 	}
 
@@ -91,12 +93,15 @@ public:
 	void deleteSubtree();
 
 	uint update_visibility();
+	void update_time();
 
 	bool m_is_unaligned;
 
 	// TODO(sergey): Can be stored as 3x3 matrix, but better to have some
 	// utilities and type defines in util_transform first.
 	Transform *m_aligned_space;
+
+	float m_time_from, m_time_to;
 };
 
 class InnerNode : public BVHNode
diff --git a/intern/cycles/bvh/bvh_params.h b/intern/cycles/bvh/bvh_params.h
index 6d426475737..65f9da1c194 100644
--- a/intern/cycles/bvh/bvh_params.h
+++ b/intern/cycles/bvh/bvh_params.h
@@ -61,6 +61,17 @@ public:
 	 */
 	bool use_unaligned_nodes;
 
+	/* Split time range to this number of steps and create leaf node for each
+	 * of this time steps.
+	 *
+	 * Speeds up rendering of motion curve primitives in the cost of higher
+	 * memory usage.
+	 */
+	int num_motion_curve_steps;
+
+	/* Same as above, but for triangle primitives. */
+	int num_motion_triangle_steps;
+
 	/* fixed parameters */
 	enum {
 		MAX_DEPTH = 64,
@@ -91,6 +102,8 @@ public:
 		use_unaligned_nodes = false;
 
 		primitive_mask = PRIMITIVE_ALL;
+
+		num_motion_curve_steps = 0;
 	}
 
 	/* SAH costs */
@@ -117,8 +130,15 @@ class BVHReference
 public:
 	__forceinline BVHReference() {}
 
-	__forceinline BVHReference(const BoundBox& bounds_, int prim_index_, int prim_object_, int prim_type)
-	: rbounds(bounds_)
+	__forceinline BVHReference(const BoundBox& bounds_,
+	                           int prim_index_,
+	                           int prim_object_,
+	                           int prim_type,
+	                           float time_from = 0.0f,
+	                           float time_to = 1.0f)
+	        : rbounds(bounds_),
+	          time_from_(time_from),
+	          time_to_(time_to)
 	{
 		rbounds.min.w = __int_as_float(prim_index_);
 		rbounds.max.w = __int_as_float(prim_object_);
@@ -129,6 +149,9 @@ public:
 	__forceinline int prim_index() const { return __float_as_int(rbounds.min.w); }
 	__forceinline int prim_object() const { return __float_as_int(rbounds.max.w); }
 	__forceinline int prim_type() const { return type; }
+	__forceinline float time_from() const { return time_from_; }
+	__forceinline float time_to() const { return time_to_; }
+
 
 	BVHReference& operator=(const BVHReference &arg) {
 		if(&arg != this) {
@@ -137,9 +160,11 @@ public:
 		return *this;
 	}
 
+
 protected:
 	BoundBox rbounds;
 	uint type;
+	float time_from_, time_to_;
 };
 
 /* BVH Range
diff --git a/intern/cycles/kernel/CMakeLists.txt b/intern/cycles/kernel/CMakeLists.txt
index 56bcafbce38..29e0f44841e 100644
--- a/intern/cycles/kernel/CMakeLists.txt
+++ b/intern/cycles/kernel/CMakeLists.txt
@@ -164,6 +164,8 @@ set(SRC_GEOM_HEADERS
 	geom/geom_curve.h
 	geom/geom_motion_curve.h
 	geom/geom_motion_triangle.h
+	geom/geom_motion_triangle_intersect.h
+	geom/geom_motion_triangle_shader.h
 	geom/geom_object.h
 	geom/geom_patch.h
 	geom/geom_primitive.h
diff --git a/intern/cycles/kernel/bvh/qbvh_shadow_all.h b/intern/cycles/kernel/bvh/qbvh_shadow_all.h
index b2e99725626..607295f9ed5 100644
--- a/intern/cycles/kernel/bvh/qbvh_shadow_all.h
+++ b/intern/cycles/kernel/bvh/qbvh_shadow_all.h
@@ -106,14 +106,20 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
 			while(node_addr >= 0 && node_addr != ENTRYPOINT_SENTINEL) {
 				float4 inodes = kernel_tex_fetch(__bvh_nodes, node_addr+0);
 
+				if(false
 #ifdef __VISIBILITY_FLAG__
-				if((__float_as_uint(inodes.x) & PATH_RAY_SHADOW) == 0) {
+				   || ((__float_as_uint(inodes.x) & PATH_RAY_SHADOW) == 0)
+#endif
+#if BVH_FEATURE(BVH_MOTION)
+				   || UNLIKELY(ray->time < inodes.y)
+				   || UNLIKELY(ray->time > inodes.z)
+#endif
+				) {
 					/* Pop. */
 					node_addr = traversal_stack[stack_ptr].addr;
 					--stack_ptr;
 					continue;
 				}
-#endif
 
 				ssef dist;
 				int child_mask = NODE_INTERSECT(kg,
diff --git a/intern/cycles/kernel/bvh/qbvh_traversal.h b/intern/cycles/kernel/bvh/qbvh_traversal.h
index 1d5643ca540..10ae7bee852 100644
--- a/intern/cycles/kernel/bvh/qbvh_traversal.h
+++ b/intern/cycles/kernel/bvh/qbvh_traversal.h
@@ -117,6 +117,10 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
 				float4 inodes = kernel_tex_fetch(__bvh_nodes, node_addr+0);
 
 				if(UNLIKELY(node_dist > isect->t)
+#if BVH_FEATURE(BVH_MOTION)
+				   || UNLIKELY(ray->time < inodes.y)
+				   || UNLIKELY(ray->time > inodes.z)
+#endif
 #ifdef __VISIBILITY_FLAG__
 				   || (__float_as_uint(inodes.x) & visibility) == 0)
 #endif
diff --git a/intern/cycles/kernel/geom/geom.h b/intern/cycles/kernel/geom/geom.h
index 24ced934c8b..6838e26c242 100644
--- a/intern/cycles/kernel/geom/geom.h
+++ b/intern/cycles/kernel/geom/geom.h
@@ -23,6 +23,8 @@
 #include "geom_subd_triangle.h"
 #include "geom_triangle_intersect.h"
 #include "geom_motion_triangle.h"
+#include "geom_motion_triangle_intersect.h"
+#include "geom_motion_triangle_shader.h"
 #include "geom_motion_curve.h"
 #include "geom_curve.h"
 #include "geom_volume.h"
diff --git a/intern/cycles/kernel/geom/geom_motion_curve.h b/intern/cycles/kernel/geom/geom_motion_curve.h
index 80b33fad68b..dc1388b6643 100644
--- a/intern/cycles/kernel/geom/geom_motion_curve.h
+++ b/intern/cycles/kernel/geom/geom_motion_curve.h
@@ -50,12 +50,12 @@ ccl_device_inline int find_attribute_curve_motion(KernelGlobals *kg, int object,
 ccl_device_inline void motion_curve_keys_for_step(KernelGlobals *kg, int offset, int numkeys, int numsteps, int step, int k0, int k1, float4 keys[2])
 {
 	if(step == numsteps) {
-		/* center step: regular vertex location */
+		/* center step: regular key location */
 		keys[0] = kernel_tex_fetch(__curve_keys, k0);
 		keys[1] = kernel_tex_fetch(__curve_keys, k1);
 	}
 	else {
-		/* center step not stored in this array */
+		/* center step is not stored in this array */
 		if(step > numsteps)
 			step--;
 
@@ -97,14 +97,14 @@ ccl_device_inline void motion_curve_keys(KernelGlobals *kg, int object, int prim
 ccl_device_inline void motion_cardinal_curve_keys_for_step(KernelGlobals *kg, int offset, int numkeys, int numsteps, int step, int k0, int k1, int k2, int k3, float4 keys[4])
 {
 	if(step == numsteps) {
-		/* center step: regular vertex location */
+		/* center step: regular key location */
 		keys[0] = kernel_tex_fetch(__curve_keys, k0);
 		keys[1] = kernel_tex_fetch(__curve_keys, k1);
 		keys[2] = kernel_tex_fetch(__curve_keys, k2);
 		keys[3] = kernel_tex_fetch(__curve_keys, k3);
 	}
 	else {
-		/* center step not store in this array */
+		/* center step is not stored in this array */
 		if(step > numsteps)
 			step--;
 
diff --git a/intern/cycles/kernel/geom/geom_motion_triangle.h b/intern/cycles/kernel/geom/geom_motion_triangle.h
index 538c332c63a..4e84aa97776 100644
--- a/intern/cycles/kernel/geom/geom_motion_triangle.h
+++ b/intern/cycles/kernel/geom/geom_motion_triangle.h
@@ -76,7 +76,7 @@ ccl_device_inline void motion_triangle_normals_for_step(KernelGlobals *kg, uint4
 		normals[2] = float4_to_float3(kernel_tex_fetch(__tri_vnormal, tri_vindex.z));
 	}
 	else {
-		/* center step not stored in this array */
+		/* center step is not stored in this array */
 		if(step > numsteps)
 			step--;
 
@@ -117,312 +117,4 @@ ccl_device_inline void motion_triangle_vertices(KernelGlobals *kg, int object, i
 	verts[2] = (1.0f - t)*verts[2] + t*next_verts[2];
 }
 
-/* Refine triangle intersection to more precise hit point. For rays that travel
- * far the precision is often not so good, this reintersects the primitive from
- * a closer distance. */
-
-ccl_device_inline float3 motion_triangle_refine(KernelGlobals *kg, ShaderData *sd, const Intersection *isect, const Ray *ray, float3 verts[3])
-{
-	float3 P = ray->P;
-	float3 D = ray->D;
-	float t = isect->t;
-
-#ifdef __INTERSECTION_REFINE__
-	if(isect->object != OBJECT_NONE) {
-		if(UNLIKELY(t == 0.0f)) {
-			return P;
-		}
-#  ifdef __OBJECT_MOTION__
-		Transform tfm = ccl_fetch(sd, ob_itfm);
-#  else
-		Transform tfm = object_fetch_transform(kg, isect->object, OBJECT_INVERSE_TRANSFORM);
-#  endif
-
-		P = transform_point(&tfm, P);
-		D = transform_direction(&tfm, D*t);
-		D = normalize_len(D, &t);
-	}
-
-	P = P + D*t;
-
-	/* compute refined intersection distance */
-	const float3 e1 = verts[0] - verts[2];
-	const float3 e2 = verts[1] - verts[2];
-	const float3 s1 = cross(D, e2);
-
-	const float invdivisor = 1.0f/dot(s1, e1);
-	const float3 d = P - verts[2];
-	const float3 s2 = cross(d, e1);
-	float rt = dot(e2, s2)*invdivisor;
-
-	/* compute refined position */
-	P = P + D*rt;
-
-	if(isect->object != OBJECT_NONE) {
-#  ifdef __OBJECT_MOTION__
-		Transform tfm = ccl_fetch(sd, ob_tfm);
-#  else
-		Transform tfm = object_fetch_transform(kg, isect->object, OBJECT_TRANSFORM);
-#  endif
-
-		P = transform_point(&tfm, P);
-	}
-
-	return P;
-#else
-	return P + D*t;
-#endif
-}
-
-/* Same as above, except that isect->t is assumed to be in object space for instancing */
-
-#ifdef __SUBSURFACE__
-#  if defined(__KERNEL_CUDA__) && (defined(i386) || defined(_M_IX86))
-ccl_device_noinline
-#  else
-ccl_device_inline
-#  endif
-float3 motion_triangle_refine_subsurface(KernelGlobals *kg, ShaderData *sd, const Intersection *isect, const Ray *ray, float3 verts[3])
-{
-	float3 P = ray->P;
-	float3 D = ray->D;
-	float t = isect->t;
-
-#  ifdef __INTERSECTION_REFINE__
-	if(isect->object != OBJECT_NONE) {
-#    ifdef __OBJECT_MOTION__
-		Transform tfm = ccl_fetch(sd, ob_itfm);
-#    else
-		Transform tfm = object_fetch_transform(kg, isect->object, OBJECT_INVERSE_TRANSFORM);
-#    endif
-
-		P = transform_point(&tfm, P);
-		D = transform_direction(&tfm, D);
-		D = normalize(D);
-	}
-
-	P = P + D*t;
-
-	/* compute refined intersection distance */
-	const float3 e1 = verts[0] - verts[2];
-	const float3 e2 = verts[1] - verts[2];
-	const float3 s1 = cross(D, e2);
-
-	const float invdivisor = 1.0f/dot(s1, e1);
-	const float3 d = P - verts[2];
-	const float3 s2 = cross(d, e1);
-	float rt = dot(e2, s2)*invdivisor;
-
-	P = P + D*rt;
-
-	if(isect->object != OBJECT_NONE) {
-#    ifdef __OBJECT_MOTION__
-		Transform tfm = ccl_fetch(sd, ob_tfm);
-#    else
-		Transform tfm = object_fetch_transform(kg, isect->object, OBJECT_TRANSFORM);
-#    endif
-
-		P = transform_point(&tfm, P);
-	}
-
-	return P;
-#  else
-	return P + D*t;
-#  endif
-}
-#endif
-
-/* Setup of motion triangle specific parts of ShaderData, moved into this one
- * function to more easily share computation of interpolated positions and
- * normals */
-
-/* return 3 triangle vertex normals */
-ccl_device_noinline void motion_triangle_shader_setup(KernelGlobals *kg, ShaderData *sd, const Intersection *isect, const Ray *ray, bool subsurface)
-{
-	/* get shader */
-	ccl_fetch(sd, shader) = kernel_tex_fetch(__tri_shader, ccl_fetch(sd, prim));
-
-	/* get motion info */
-	int numsteps, numverts;
-	object_motion_info(kg, ccl_fetch(sd, object), &numsteps, &numverts, NULL);
-
-	/* figure out which steps we need to fetch and their interpolation factor */
-	int maxstep = numsteps*2;
-	int step = min((int)(ccl_fetch(sd, time)*maxstep), maxstep-1);
-	float t = ccl_fetch(sd, time)*maxstep - step;
-
-	/* find attribute */
-	AttributeElement elem;
-	int offset = find_attribute_motion(kg, ccl_fetch(sd, object), ATTR_STD_MOTION_VERTEX_POSITION, &elem);
-	kernel_assert(offset != ATTR_STD_NOT_FOUND);
-
-	/* fetch vertex coordinates */
-	float3 verts[3], next_verts[3];
-	uint4 tri_vindex = kernel_tex_fetch(__tri_vindex, ccl_fetch(sd, prim));
-
-	motion_triangle_verts_for_step(kg, tri_vindex, offset, numverts, numsteps, step, verts);
-	motion_triangle_verts_for_step(kg, tri_vindex, offset, numverts, numsteps, step+1, next_verts);
-
-	/* interpolate between steps */
-	verts[0] = (1.0f - t)*verts[0] + t*next_verts[0];
-	verts[1] = (1.0f - t)*verts[1] + t*next_verts[1];
-	verts[2] = (1.0f - t)*verts[2] + t*next_verts[2];
-
-	/* compute refined position */
-#ifdef __SUBSURFACE__
-	if(!subsurface)
-#endif
-		ccl_fetch(sd, P) = motion_triangle_refine(kg, sd, isect, ray, verts);
-#ifdef __SUBSURFACE__
-	else
-		ccl_fetch(sd, P) = motion_triangle_refine_subsurface(kg, sd, isect, ray, verts);
-#endif
-
-	/* compute face normal */
-	float3 Ng;
-	if(ccl_fetch(sd, flag) & SD_NEGATIVE_SCALE_APPLIED)
-		Ng = normalize(cross(verts[2] - verts[0], verts[1] - verts[0]));
-	else
-		Ng = normalize(cross(verts[1] - verts[0], verts[2] - verts[0]));
-
-	ccl_fetch(sd, Ng) = Ng;
-	ccl_fetch(sd, N) = Ng;
-
-	/* compute derivatives of P w.r.t. uv */
-#ifdef __DPDU__
-	ccl_fetch(sd, dPdu) = (verts[0] - verts[2]);
-	ccl_fetch(sd, dPdv) = (verts[1] - verts[2]);
-#endif
-
-	/* compute smooth normal */
-	if(ccl_fetch(sd, shader) & SHADER_SMOOTH_NORMAL) {
-		/* find attribute */
-		AttributeElement elem;
-		int offset = find_attribute_motion(kg, ccl_fetch(sd, object), ATTR_STD_MOTION_VERTEX_NORMAL, &elem);
-		kernel_assert(offset != ATTR_STD_NOT_FOUND);
-
-		/* fetch vertex coordinates */
-		float3 normals[3], next_normals[3];
-		motion_triangle_normals_for_step(kg, tri_vindex, offset, numverts, numsteps, step, normals);
-		motion_triangle_normals_for_step(kg, tri_vindex, offset, numverts, numsteps, step+1, next_normals);
-
-		/* interpolate between steps */
-		normals[0] = (1.0f - t)*normals[0] + t*next_normals[0];
-		normals[1] = (1.0f - t)*normals[1] + t*next_normals[1];
-		normals[2] = (1.0f - t)*normals[2] + t*next_normals[2];
-
-		/* interpolate between vertices */
-		float u = ccl_fetch(sd, u);
-		float v = ccl_fetch(sd, v);
-		float w = 1.0f - u - v;
-		ccl_fetch(sd, N) = (u*normals[0] + v*normals[1] + w*normals[2]);
-	}
-}
-
-/* Ray intersection. We simply compute the vertex positions at the given ray
- * time and do a ray intersection with the resulting triangle */
-
-ccl_device_inline bool motion_triangle_intersect(KernelGlobals *kg, Intersection *isect,
-	float3 P, float3 dir, float time, uint visibility, int object, int prim_addr)
-{
-	/* primitive index for vertex location lookup */
-	int prim = kernel_tex_fetch(__prim_index, prim_addr);
-	int fobject = (object == OBJECT_NONE)? kernel_tex_fetch(__prim_object, prim_addr): object;
-
-	/* get vertex locations for intersection */
-	float3 verts[3];
-	motion_triangle_vertices(kg, fobject, prim, time, verts);
-
-	/* ray-triangle intersection, unoptimized */
-	float t, u, v;
-
-	if(ray_triangle_intersect_uv(P, dir, isect->t, verts[2], verts[0], verts[1], &u, &v, &t)) {
-#ifdef __VISIBILITY_FLAG__
-		/* visibility flag test. we do it here under the assumption
-		 * that most triangles are culled by node flags */
-		if(kernel_tex_fetch(__prim_visibility, prim_addr) & visibility)
-#endif
-		{
-			isect->t = t;
-			isect->u = u;
-			isect->v = v;
-			isect->prim = prim_addr;
-			isect->object = object;
-			isect->type = PRIMITIVE_MOTION_TRIANGLE;
-		
-			return true;
-		}
-	}
-
-	return false;
-}
-
-/* Special ray intersection routines for subsurface scattering. In that case we
- * only want to intersect with primitives in the same object, and if case of
- * multiple hits we pick a single random primitive as the intersection point. */
-
-#ifdef __SUBSURFACE__
-ccl_device_inline void motion_triangle_intersect_subsurface(
-        KernelGlobals *kg,
-        SubsurfaceIntersection *ss_isect,
-        float3 P,
-        float3 dir,
-        float time,
-        int object,
-        int prim_addr,
-        float tmax,
-        uint *lcg_state,
-        int max_hits)
-{
-	/* primitive index for vertex location lookup */
-	int prim = kernel_tex_fetch(__prim_index, prim_addr);
-	int fobject = (object == OBJECT_NONE)? kernel_tex_fetch(__prim_object, prim_addr): object;
-
-	/* get vertex locations for intersection */
-	float3 verts[3];
-	motion_triangle_vertices(kg, fobject, prim, time, verts);
-
-	/* ray-triangle intersection, unoptimized */
-	float t, u, v;
-
-	if(ray_triangle_intersect_uv(P, dir, tmax, verts[2], verts[0], verts[1], &u, &v, &t)) {
-		for(int i = min(max_hits, ss_isect->num_hits) - 1; i >= 0; --i) {
-			if(ss_isect->hits[i].t == t) {
-				return;
-			}
-		}
-
-		ss_isect->num_hits++;
-
-		int hit;
-
-		if(ss_isect->num_hits <= max_hits) {
-			hit = ss_isect->num_hits - 1;
-		}
-		else {
-			/* reservoir sampling: if we are at the maximum number of
-			 * hits, randomly replace element or skip it */
-			hit = lcg_step_uint(lcg_state) % ss_isect->num_hits;
-
-			if(hit >= max_hits)
-				return;
-		}
-
-		/* record intersection */
-		Intersection *isect = &ss_isect->hits[hit];
-		isect->t = t;
-		isect->u = u;
-		isect->v = v;
-		isect->prim = prim_addr;
-		isect->object = object;
-		isect->type = PRIMITIVE_MOTION_TRIANGLE;
-
-		/* Record geometric normal. */
-		ss_isect->Ng[hit] = normalize(cross(verts[1] - verts[0],
-		                                    verts[2] - verts[0]));
-	}
-}
-#endif
-
 CCL_NAMESPACE_END
-
diff --git a/intern/cycles/kernel/geom/geom_motion_triangle_intersect.h b/intern/cycles/kernel/geom/geom_motion_triangle_intersect.h
new file mode 100644
index 00000000000..d57d74ea882
--- /dev/null
+++ b/intern/cycles/kernel/geom/geom_motion_triangle_intersect.h
@@ -0,0 +1,280 @@
+/*
+ * Copyright 2011-2016 Blender Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* Motion Triangle Primitive
+ *
+ * These are stored as regular triangles, plus extra positions and normals at
+ * times other than the frame center. Computing the triangle vertex positions
+ * or normals at a given ray time is a matter of interpolation of the two steps
+ * between which the ray time lies.
+ *
+ * The extra positions and normals are stored as ATTR_STD_MOTION_VERTEX_POSITION
+ * and ATTR_STD_MOTION_VERTEX_NORMAL mesh attributes.
+ */
+
+CCL_NAMESPACE_BEGIN
+
+/* Refine triangle intersection to more precise hit point. For rays that travel
+ * far the precision is often not so good, this reintersects the primitive from
+ * a closer distance.
+ */
+
+ccl_device_inline float3 motion_triangle_refine(KernelGlobals *kg,
+                                                ShaderData *sd,
+                                                const Intersection *isect,
+                                                const Ray *ray,
+                                                float3 verts[3])
+{
+	float3 P = ray->P;
+	float3 D = ray->D;
+	float t = isect->t;
+
+#ifdef __INTERSECTION_REFINE__
+	if(isect->object != OBJECT_NONE) {
+		if(UNLIKELY(t == 0.0f)) {
+			return P;
+		}
+#  ifdef __OBJECT_MOTION__
+		Transform tfm = ccl_fetch(sd, ob_itfm);
+#  else
+		Transform tfm = object_fetch_transform(kg,
+		                                       isect->object,
+		                                       OBJECT_INVERSE_TRANSFORM);
+#  endif
+
+		P = transform_point(&tfm, P);
+		D = transform_direction(&tfm, D*t);
+		D = normalize_len(D, &t);
+	}
+
+	P = P + D*t;
+
+	/* Compute refined intersection distance. */
+	const float3 e1 = verts[0] - verts[2];
+	const float3 e2 = verts[1] - verts[2];
+	const float3 s1 = cross(D, e2);
+
+	const float invdivisor = 1.0f/dot(s1, e1);
+	const float3 d = P - verts[2];
+	const float3 s2 = cross(d, e1);
+	float rt = dot(e2, s2)*invdivisor;
+
+	/* Compute refined position. */
+	P = P + D*rt;
+
+	if(isect->object != OBJECT_NONE) {
+#  ifdef __OBJECT_MOTION__
+		Transform tfm = ccl_fetch(sd, ob_tfm);
+#  else
+		Transform tfm = object_fetch_transform(kg,
+		                                       isect->object,
+		                                       OBJECT_TRANSFORM);
+#  endif
+
+		P = transform_point(&tfm, P);
+	}
+
+	return P;
+#else
+	return P + D*t;
+#endif
+}
+
+/* Same as above, except that isect->t is assumed to be in object space
+ * for instancing.
+ */
+
+#ifdef __SUBSURFACE__
+#  if defined(__KERNEL_CUDA__) && (defined(i386) || defined(_M_IX86))
+ccl_device_noinline
+#  else
+ccl_device_inline
+#  endif
+float3 motion_triangle_refine_subsurface(KernelGlobals *kg,
+                                         ShaderData *sd,
+                                         const Intersection *isect,
+                                         const Ray *ray,
+                                         float3 verts[3])
+{
+	float3 P = ray->P;
+	float3 D = ray->D;
+	float t = isect->t;
+
+#  ifdef __INTERSECTION_REFINE__
+	if(isect->object != OBJECT_NONE) {
+#    ifdef __OBJECT_MOTION__
+		Transform tfm = ccl_fetch(sd, ob_itfm);
+#    else
+		Transform tfm = object_fetch_transform(kg,
+		                                       isect->object,
+		                                       OBJECT_INVERSE_TRANSFORM);
+#    endif
+
+		P = transform_point(&tfm, P);
+		D = transform_direction(&tfm, D);
+		D = normalize(D);
+	}
+
+	P = P + D*t;
+
+	/* compute refined intersection distance */
+	const float3 e1 = verts[0] - verts[2];
+	const float3 e2 = verts[1] - verts[2];
+	const float3 s1 = cross(D, e2);
+
+	const float invdivisor = 1.0f/dot(s1, e1);
+	const float3 d = P - verts[2];
+	const float3 s2 = cross(d, e1);
+	float rt = dot(e2, s2)*invdivisor;
+
+	P = P + D*rt;
+
+	if(isect->object != OBJECT_NONE) {
+#    ifdef __OBJECT_MOTION__
+		Transform tfm = ccl_fetch(sd, ob_tfm);
+#    else
+		Transform tfm = object_fetch_transform(kg,
+		                                       isect->object,
+		                                       OBJECT_TRANSFORM);
+#    endif
+
+		P = transform_point(&tfm, P);
+	}
+
+	return P;
+#  else  /* __INTERSECTION_REFINE__ */
+	return P + D*t;
+#  endif  /* __INTERSECTION_REFINE__ */
+}
+#endif  /* __SUBSURFACE__ */
+
+
+/* Ray intersection. We simply compute the vertex positions at the given ray
+ * time and do a ray intersection with the resulting triangle.
+ */
+
+ccl_device_inline bool motion_triangle_intersect(KernelGlobals *kg,
+                                                 Intersection *isect,
+                                                 float3 P,
+                                                 float3 dir,
+                                                 float time,
+                                                 uint visibility,
+                                                 int object,
+                                                 int prim_addr)
+{
+	/* Primitive index for vertex location lookup. */
+	int prim = kernel_tex_fetch(__prim_index, prim_addr);
+	int fobject = (object == OBJECT_NONE)
+	                  ? kernel_tex_fetch(__prim_object, prim_addr)
+	                  : object;
+	/* Get vertex locations for intersection. */
+	float3 verts[3];
+	motion_triangle_vertices(kg, fobject, prim, time, verts);
+	/* Ray-triangle intersection, unoptimized. */
+	float t, u, v;
+	if(ray_triangle_intersect_uv(P,
+	                             dir,
+	                             isect->t,
+	                             verts[2], verts[0], verts[1],
+	                             &u, &v, &t))
+	{
+#ifdef __VISIBILITY_FLAG__
+		/* Visibility flag test. we do it here under the assumption
+		 * that most triangles are culled by node flags.
+		 */
+		if(kernel_tex_fetch(__prim_visibility, prim_addr) & visibility)
+#endif
+		{
+			isect->t = t;
+			isect->u = u;
+			isect->v = v;
+			isect->prim = prim_addr;
+			isect->object = object;
+			isect->type = PRIMITIVE_MOTION_TRIANGLE;
+			return true;
+		}
+	}
+	return false;
+}
+
+/* Special ray intersection routines for subsurface scattering. In that case we
+ * only want to intersect with primitives in the same object, and if case of
+ * multiple hits we pick a single random primitive as the intersection point.
+ */
+#ifdef __SUBSURFACE__
+ccl_device_inline void motion_triangle_intersect_subsurface(
+        KernelGlobals *kg,
+        SubsurfaceIntersection *ss_isect,
+        float3 P,
+        float3 dir,
+        float time,
+        int object,
+        int prim_addr,
+        float tmax,
+        uint *lcg_state,
+        int max_hits)
+{
+	/* Primitive index for vertex location lookup. */
+	int prim = kernel_tex_fetch(__prim_index, prim_addr);
+	int fobject = (object == OBJECT_NONE)
+	                  ? kernel_tex_fetch(__prim_object, prim_addr)
+	                  : object;
+	/* Get vertex locations for intersection. */
+	float3 verts[3];
+	motion_triangle_vertices(kg, fobject, prim, time, verts);
+	/* Ray-triangle intersection, unoptimized. */
+	float t, u, v;
+	if(ray_triangle_intersect_uv(P,
+	                             dir,
+	                             tmax,
+	                             verts[2], verts[0], verts[1],
+	                             &u, &v, &t))
+	{
+		for(int i = min(max_hits, ss_isect->num_hits) - 1; i >= 0; --i) {
+			if(ss_isect->hits[i].t == t) {
+				return;
+			}
+		}
+		ss_isect->num_hits++;
+		int hit;
+		if(ss_isect->num_hits <= max_hits) {
+			hit = ss_isect->num_hits - 1;
+		}
+		else {
+			/* Reservoir sampling: if we are at the maximum number of
+			 * hits, randomly replace element or skip it.
+			 */
+			hit = lcg_step_uint(lcg_state) % ss_isect->num_hits;
+
+			if(hit >= max_hits)
+				return;
+		}
+		/* Record intersection. */
+		Intersection *isect = &ss_isect->hits[hit];
+		isect->t = t;
+		isect->u = u;
+		isect->v = v;
+		isect->prim = prim_addr;
+		isect->object = object;
+		isect->type = PRIMITIVE_MOTION_TRIANGLE;
+		/* Record geometric normal. */
+		ss_isect->Ng[hit] = normalize(cross(verts[1] - verts[0],
+		                                    verts[2] - verts[0]));
+	}
+}
+#endif  /* __SUBSURFACE__ */
+
+CCL_NAMESPACE_END
diff --git a/intern/cycles/kernel/geom/geom_motion_triangle_shader.h b/intern/cycles/kernel/geom/geom_motion_triangle_shader.h
new file mode 100644
index 00000000000..c5dbc6a2f52
--- /dev/null
+++ b/intern/cycles/kernel/geom/geom_motion_triangle_shader.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2011-2016 Blender Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* Motion Triangle Primitive
+ *
+ * These are stored as regular triangles, plus extra positions and normals at
+ * times other than the frame center. Computing the triangle vertex positions
+ * or normals at a given ray time is a matter of interpolation of the two steps
+ * between which the ray time lies.
+ *
+ * The extra positions and normals are stored as ATTR_STD_MOTION_VERTEX_POSITION
+ * and ATTR_STD_MOTION_VERTEX_NORMAL mesh attributes.
+ */
+
+CCL_NAMESPACE_BEGIN
+
+/* Setup of motion triangle specific parts of ShaderData, moved into this one
+ * function to more easily share computation of interpolated positions and
+ * normals */
+
+/* return 3 triangle vertex normals */
+ccl_device_noinline void motion_triangle_shader_setup(KernelGlobals *kg,
+                                                      ShaderData *sd, const
+                                                      Intersection *isect,
+                                                      const Ray *ray,
+                                                      bool subsurface)
+{
+	/* Get shader. */
+	ccl_fetch(sd, shader) = kernel_tex_fetch(__tri_shader, ccl_fetch(sd, prim));
+	/* Get motion info. */
+	/* TODO(sergey): This logic is really similar to motion_triangle_vertices(),
+	 * can we de-duplicate something here?
+	 */
+	int numsteps, numverts;
+	object_motion_info(kg, ccl_fetch(sd, object), &numsteps, &numverts, NULL);
+	/* Figure out which steps we need to fetch and their interpolation factor. */
+	int maxstep = numsteps*2;
+	int step = min((int)(ccl_fetch(sd, time)*maxstep), maxstep-1);
+	float t = ccl_fetch(sd, time)*maxstep - step;
+	/* Find attribute. */
+	AttributeElement elem;
+	int offset = find_attribute_motion(kg, ccl_fetch(sd, object),
+	                                   ATTR_STD_MOTION_VERTEX_POSITION,
+	                                   &elem);
+	kernel_assert(offset != ATTR_STD_NOT_FOUND);
+	/* Fetch vertex coordinates. */
+	float3 verts[3], next_verts[3];
+	uint4 tri_vindex = kernel_tex_fetch(__tri_vindex, ccl_fetch(sd, prim));
+	motion_triangle_verts_for_step(kg, tri_vindex, offset, numverts, numsteps, step, verts);
+	motion_triangle_verts_for_step(kg, tri_vindex, offset, numverts, numsteps, step+1, next_verts);
+	/* Interpolate between steps. */
+	verts[0] = (1.0f - t)*verts[0] + t*next_verts[0];
+	verts[1] = (1.0f - t)*verts[1] + t*next_verts[1];
+	verts[2] = (1.0f - t)*verts[2] + t*next_verts[2];
+	/* Compute refined position. */
+#ifdef __SUBSURFACE__
+	if(subsurface) {
+		ccl_fetch(sd, P) = motion_triangle_refine_subsurface(kg,
+		                                                     sd,
+		                                                     isect,
+		                                                     ray,
+		                                                     verts);
+	}
+	else
+#endif  /*  __SUBSURFACE__*/
+	{
+		ccl_fetch(sd, P) = motion_triangle_refine(kg, sd, isect, ray, verts);
+	}
+	/* Compute face normal. */
+	float3 Ng;
+	if(ccl_fetch(sd, flag) & SD_NEGATIVE_SCALE_APPLIED) {
+		Ng = normalize(cross(verts[2] - verts[0], verts[1] - verts[0]));
+	}
+	else {
+		Ng = normalize(cross(verts[1] - verts[0], verts[2] - verts[0]));
+	}
+	ccl_fetch(sd, Ng) = Ng;
+	ccl_fetch(sd, N) = Ng;
+	/* Compute derivatives of P w.r.t. uv. */
+#ifdef __DPDU__
+	ccl_fetch(sd, dPdu) = (verts[0] - verts[2]);
+	ccl_fetch(sd, dPdv) = (verts[1] - verts[2]);
+#endif
+	/* Compute smooth normal. */
+	if(ccl_fetch(sd, shader) & SHADER_SMOOTH_NORMAL) {
+		/* Find attribute. */
+		AttributeElement elem;
+		int offset = find_attribute_motion(kg,
+		                                   ccl_fetch(sd, object),
+		                                   ATTR_STD_MOTION_VERTEX_NORMAL,
+		                                   &elem);
+		kernel_assert(offset != ATTR_STD_NOT_FOUND);
+		/* Fetch vertex coordinates. */
+		float3 normals[3], next_normals[3];
+		motion_triangle_normals_for_step(kg, tri_vindex, offset, numverts, numsteps, step, normals);
+		motion_triangle_normals_for_step(kg, tri_vindex, offset, numverts, numsteps, step+1, next_normals);
+		/* Interpolate between steps. */
+		normals[0] = (1.0f - t)*normals[0] + t*next_normals[0];
+		normals[1] = (1.0f - t)*normals[1] + t*next_normals[1];
+		normals[2] = (1.0f - t)*normals[2] + t*next_normals[2];
+		/* Interpolate between vertices. */
+		float u = ccl_fetch(sd, u);
+		float v = ccl_fetch(sd, v);
+		float w = 1.0f - u - v;
+		ccl_fetch(sd, N) = (u*normals[0] + v*normals[1] + w*normals[2]);
+	}
+}
+
+CCL_NAMESPACE_END
+
diff --git a/intern/cycles/kernel/osl/osl_services.cpp b/intern/cycles/kernel/osl/osl_services.cpp
index 26543862b80..eeccf9a9641 100644
--- a/intern/cycles/kernel/osl/osl_services.cpp
+++ b/intern/cycles/kernel/osl/osl_services.cpp
@@ -102,6 +102,8 @@ ustring OSLRenderServices::u_curve_tangent_normal("geom:curve_tangent_normal");
 #endif
 ustring OSLRenderServices::u_path_ray_length("path:ray_length");
 ustring OSLRenderServices::u_path_ray_depth("path:ray_depth");
+ustring OSLRenderServices::u_path_diffuse_depth("path:diffuse_depth");
+ustring OSLRenderServices::u_path_glossy_depth("path:glossy_depth");
 ustring OSLRenderServices::u_path_transparent_depth("path:transparent_depth");
 ustring OSLRenderServices::u_path_transmission_depth("path:transmission_depth");
 ustring OSLRenderServices::u_trace("trace");
@@ -759,6 +761,24 @@ bool OSLRenderServices::get_background_attribute(KernelGlobals *kg, ShaderData *
 		int f = state->bounce;
 		return set_attribute_int(f, type, derivatives, val);
 	}
+	else if(name == u_path_diffuse_depth) {
+		/* Diffuse Ray Depth */
+		PathState *state = sd->osl_path_state;
+		int f = state->diffuse_bounce;
+		return set_attribute_int(f, type, derivatives, val);
+	}
+	else if(name == u_path_glossy_depth) {
+		/* Glossy Ray Depth */
+		PathState *state = sd->osl_path_state;
+		int f = state->glossy_bounce;
+		return set_attribute_int(f, type, derivatives, val);
+	}
+	else if(name == u_path_transmission_depth) {
+		/* Transmission Ray Depth */
+		PathState *state = sd->osl_path_state;
+		int f = state->transmission_bounce;
+		return set_attribute_int(f, type, derivatives, val);
+	}
 	else if(name == u_path_transparent_depth) {
 		/* Transparent Ray Depth */
 		PathState *state = sd->osl_path_state;
diff --git a/intern/cycles/kernel/osl/osl_services.h b/intern/cycles/kernel/osl/osl_services.h
index 0f2e02c62b0..ec34ca77115 100644
--- a/intern/cycles/kernel/osl/osl_services.h
+++ b/intern/cycles/kernel/osl/osl_services.h
@@ -165,6 +165,8 @@ public:
 	static ustring u_curve_tangent_normal;
 	static ustring u_path_ray_length;
 	static ustring u_path_ray_depth;
+	static ustring u_path_diffuse_depth;
+	static ustring u_path_glossy_depth;
 	static ustring u_path_transparent_depth;
 	static ustring u_path_transmission_depth;
 	static ustring u_trace;
diff --git a/intern/cycles/kernel/shaders/node_light_path.osl b/intern/cycles/kernel/shaders/node_light_path.osl
index a021a40467d..64fe4c20132 100644
--- a/intern/cycles/kernel/shaders/node_light_path.osl
+++ b/intern/cycles/kernel/shaders/node_light_path.osl
@@ -27,6 +27,8 @@ shader node_light_path(
 	output float IsVolumeScatterRay = 0.0,
 	output float RayLength = 0.0,
 	output float RayDepth = 0.0,
+	output float DiffuseDepth = 0.0,
+	output float GlossyDepth = 0.0,
 	output float TransparentDepth = 0.0,
 	output float TransmissionDepth = 0.0)
 {
@@ -45,6 +47,14 @@ shader node_light_path(
 	getattribute("path:ray_depth", ray_depth);
 	RayDepth = (float)ray_depth;
 
+	int diffuse_depth;
+	getattribute("path:diffuse_depth", diffuse_depth);
+	DiffuseDepth = (float)diffuse_depth;
+
+	int glossy_depth;
+	getattribute("path:glossy_depth", glossy_depth);
+	GlossyDepth = (float)glossy_depth;
+
 	int transparent_depth;
 	getattribute("path:transparent_depth", transparent_depth);
 	TransparentDepth = (float)transparent_depth;
diff --git a/intern/cycles/kernel/svm/svm_light_path.h b/intern/cycles/kernel/svm/svm_light_path.h
index f35ea05048b..04f6f623f18 100644
--- a/intern/cycles/kernel/svm/svm_light_path.h
+++ b/intern/cycles/kernel/svm/svm_light_path.h
@@ -34,6 +34,8 @@ ccl_device void svm_node_light_path(ShaderData *sd, ccl_addr_space PathState *st
 		case NODE_LP_backfacing: info = (ccl_fetch(sd, flag) & SD_BACKFACING)? 1.0f: 0.0f; break;
 		case NODE_LP_ray_length: info = ccl_fetch(sd, ray_length); break;
 		case NODE_LP_ray_depth: info = (float)state->bounce; break;
+		case NODE_LP_ray_diffuse: info = (float)state->diffuse_bounce; break;
+		case NODE_LP_ray_glossy: info = (float)state->glossy_bounce; break;
 		case NODE_LP_ray_transparent: info = (float)state->transparent_bounce; break;
 		case NODE_LP_ray_transmission: info = (float)state->transmission_bounce; break;
 	}
diff --git a/intern/cycles/kernel/svm/svm_types.h b/intern/cycles/kernel/svm/svm_types.h
index 5adf7d34f7f..47209ddfbab 100644
--- a/intern/cycles/kernel/svm/svm_types.h
+++ b/intern/cycles/kernel/svm/svm_types.h
@@ -188,6 +188,8 @@ typedef enum NodeLightPath {
 	NODE_LP_backfacing,
 	NODE_LP_ray_length,
 	NODE_LP_ray_depth,
+	NODE_LP_ray_diffuse,
+	NODE_LP_ray_glossy,
 	NODE_LP_ray_transparent,
 	NODE_LP_ray_transmission,
 } NodeLightPath;
diff --git a/intern/cycles/render/mesh.cpp b/intern/cycles/render/mesh.cpp
index df4327d021a..c42b32919d4 100644
--- a/intern/cycles/render/mesh.cpp
+++ b/intern/cycles/render/mesh.cpp
@@ -49,6 +49,64 @@ void Mesh::Triangle::bounds_grow(const float3 *verts, BoundBox& bounds) const
 	bounds.grow(verts[v[2]]);
 }
 
+void Mesh::Triangle::motion_verts(const float3 *verts,
+                                  const float3 *vert_steps,
+                                  size_t num_verts,
+                                  size_t num_steps,
+                                  float time,
+                                  float3 r_verts[3]) const
+{
+	/* Figure out which steps we need to fetch and their interpolation factor. */
+	const size_t max_step = num_steps - 1;
+	const size_t step = min((int)(time * max_step), max_step - 1);
+	const float t = time*max_step - step;
+	/* Fetch vertex coordinates. */
+	float3 curr_verts[3];
+	float3 next_verts[3];
+	verts_for_step(verts,
+	               vert_steps,
+	               num_verts,
+	               num_steps,
+	               step,
+	               curr_verts);
+	verts_for_step(verts,
+	               vert_steps,
+	               num_verts,
+	               num_steps,
+	               step + 1,
+	               next_verts);
+	/* Interpolate between steps. */
+	r_verts[0] = (1.0f - t)*curr_verts[0] + t*next_verts[0];
+	r_verts[1] = (1.0f - t)*curr_verts[1] + t*next_verts[1];
+	r_verts[2] = (1.0f - t)*curr_verts[2] + t*next_verts[2];
+}
+
+void Mesh::Triangle::verts_for_step(const float3 *verts,
+                                    const float3 *vert_steps,
+                                    size_t num_verts,
+                                    size_t num_steps,
+                                    size_t step,
+                                    float3 r_verts[3]) const
+{
+	const size_t center_step = ((num_steps - 1) / 2);
+	if(step == center_step) {
+		/* Center step: regular vertex location. */
+		r_verts[0] = verts[v[0]];
+		r_verts[1] = verts[v[1]];
+		r_verts[2] = verts[v[2]];
+	}
+	else {
+		/* Center step not stored in the attribute array array. */
+		if(step > center_step) {
+			step--;
+		}
+		size_t offset = step * num_verts;
+		r_verts[0] = vert_steps[offset + v[0]];
+		r_verts[1] = vert_steps[offset + v[1]];
+		r_verts[2] = vert_steps[offset + v[2]];
+	}
+}
+
 /* Curve */
 
 void Mesh::Curve::bounds_grow(const int k, const float3 *curve_keys, const float *curve_radius, BoundBox& bounds) const
@@ -104,6 +162,205 @@ void Mesh::Curve::bounds_grow(const int k,
 	bounds.grow(upper, mr);
 }
 
+void Mesh::Curve::bounds_grow(float4 keys[4], BoundBox& bounds) const
+{
+	float3 P[4] = {
+		float4_to_float3(keys[0]),
+		float4_to_float3(keys[1]),
+		float4_to_float3(keys[2]),
+		float4_to_float3(keys[3]),
+	};
+
+	float3 lower;
+	float3 upper;
+
+	curvebounds(&lower.x, &upper.x, P, 0);
+	curvebounds(&lower.y, &upper.y, P, 1);
+	curvebounds(&lower.z, &upper.z, P, 2);
+
+	float mr = max(keys[1].w, keys[2].w);
+
+	bounds.grow(lower, mr);
+	bounds.grow(upper, mr);
+}
+
+void Mesh::Curve::motion_keys(const float3 *curve_keys,
+                              const float *curve_radius,
+                              const float3 *key_steps,
+                              size_t num_curve_keys,
+                              size_t num_steps,
+                              float time,
+                              size_t k0, size_t k1,
+                              float4 r_keys[2]) const
+{
+	/* Figure out which steps we need to fetch and their interpolation factor. */
+	const size_t max_step = num_steps - 1;
+	const size_t step = min((int)(time * max_step), max_step - 1);
+	const float t = time*max_step - step;
+	/* Fetch vertex coordinates. */
+	float4 curr_keys[2];
+	float4 next_keys[2];
+	keys_for_step(curve_keys,
+	              curve_radius,
+	              key_steps,
+	              num_curve_keys,
+	              num_steps,
+	              step,
+	              k0, k1,
+	              curr_keys);
+	keys_for_step(curve_keys,
+	              curve_radius,
+	              key_steps,
+	              num_curve_keys,
+	              num_steps,
+	              step + 1,
+	              k0, k1,
+	              next_keys);
+	/* Interpolate between steps. */
+	r_keys[0] = (1.0f - t)*curr_keys[0] + t*next_keys[0];
+	r_keys[1] = (1.0f - t)*curr_keys[1] + t*next_keys[1];
+}
+
+void Mesh::Curve::cardinal_motion_keys(const float3 *curve_keys,
+                                       const float *curve_radius,
+                                       const float3 *key_steps,
+                                       size_t num_curve_keys,
+                                       size_t num_steps,
+                                       float time,
+                                       size_t k0, size_t k1,
+                                       size_t k2, size_t k3,
+                                       float4 r_keys[4]) const
+{
+	/* Figure out which steps we need to fetch and their interpolation factor. */
+	const size_t max_step = num_steps - 1;
+	const size_t step = min((int)(time * max_step), max_step - 1);
+	const float t = time*max_step - step;
+	/* Fetch vertex coordinates. */
+	float4 curr_keys[4];
+	float4 next_keys[4];
+	cardinal_keys_for_step(curve_keys,
+	                       curve_radius,
+	                       key_steps,
+	                       num_curve_keys,
+	                       num_steps,
+	                       step,
+	                       k0, k1, k2, k3,
+	                       curr_keys);
+	cardinal_keys_for_step(curve_keys,
+	                       curve_radius,
+	                       key_steps,
+	                       num_curve_keys,
+	                       num_steps,
+	                       step + 1,
+	                       k0, k1, k2, k3,
+	                       next_keys);
+	/* Interpolate between steps. */
+	r_keys[0] = (1.0f - t)*curr_keys[0] + t*next_keys[0];
+	r_keys[1] = (1.0f - t)*curr_keys[1] + t*next_keys[1];
+	r_keys[2] = (1.0f - t)*curr_keys[2] + t*next_keys[2];
+	r_keys[3] = (1.0f - t)*curr_keys[3] + t*next_keys[3];
+}
+
+void Mesh::Curve::keys_for_step(const float3 *curve_keys,
+                                const float *curve_radius,
+                                const float3 *key_steps,
+                                size_t num_curve_keys,
+                                size_t num_steps,
+                                size_t step,
+                                size_t k0, size_t k1,
+                                float4 r_keys[2]) const
+{
+	k0 = max(k0, 0);
+	k1 = min(k1, num_keys - 1);
+	const size_t center_step = ((num_steps - 1) / 2);
+	if(step == center_step) {
+		/* Center step: regular key location. */
+		/* TODO(sergey): Consider adding make_float4(float3, float)
+		 * function.
+		 */
+		r_keys[0] = make_float4(curve_keys[first_key + k0].x,
+		                        curve_keys[first_key + k0].y,
+		                        curve_keys[first_key + k0].z,
+		                        curve_radius[first_key + k0]);
+		r_keys[1] = make_float4(curve_keys[first_key + k1].x,
+		                        curve_keys[first_key + k1].y,
+		                        curve_keys[first_key + k1].z,
+		                        curve_radius[first_key + k1]);
+	}
+	else {
+		/* Center step is not stored in this array. */
+		if(step > center_step) {
+			step--;
+		}
+		const size_t offset = first_key + step * num_curve_keys;
+		r_keys[0] = make_float4(key_steps[offset + k0].x,
+		                        key_steps[offset + k0].y,
+		                        key_steps[offset + k0].z,
+		                        curve_radius[first_key + k0]);
+		r_keys[1] = make_float4(key_steps[offset + k1].x,
+		                        key_steps[offset + k1].y,
+		                        key_steps[offset + k1].z,
+		                        curve_radius[first_key + k1]);
+	}
+}
+
+void Mesh::Curve::cardinal_keys_for_step(const float3 *curve_keys,
+                                         const float *curve_radius,
+                                         const float3 *key_steps,
+                                         size_t num_curve_keys,
+                                         size_t num_steps,
+                                         size_t step,
+                                         size_t k0, size_t k1,
+                                         size_t k2, size_t k3,
+                                         float4 r_keys[4]) const
+{
+	k0 = max(k0, 0);
+	k3 = min(k3, num_keys - 1);
+	const size_t center_step = ((num_steps - 1) / 2);
+	if(step == center_step) {
+		/* Center step: regular key location. */
+		r_keys[0] = make_float4(curve_keys[first_key + k0].x,
+		                        curve_keys[first_key + k0].y,
+		                        curve_keys[first_key + k0].z,
+		                        curve_radius[first_key + k0]);
+		r_keys[1] = make_float4(curve_keys[first_key + k1].x,
+		                        curve_keys[first_key + k1].y,
+		                        curve_keys[first_key + k1].z,
+		                        curve_radius[first_key + k1]);
+		r_keys[2] = make_float4(curve_keys[first_key + k2].x,
+		                        curve_keys[first_key + k2].y,
+		                        curve_keys[first_key + k2].z,
+		                        curve_radius[first_key + k2]);
+		r_keys[3] = make_float4(curve_keys[first_key + k3].x,
+		                        curve_keys[first_key + k3].y,
+		                        curve_keys[first_key + k3].z,
+		                        curve_radius[first_key + k3]);
+	}
+	else {
+		/* Center step is not stored in this array. */
+		if(step > center_step) {
+			step--;
+		}
+		const size_t offset = first_key + step * num_curve_keys;
+		r_keys[0] = make_float4(key_steps[offset + k0].x,
+		                        key_steps[offset + k0].y,
+		                        key_steps[offset + k0].z,
+		                        curve_radius[first_key + k0]);
+		r_keys[1] = make_float4(key_steps[offset + k1].x,
+		                        key_steps[offset + k1].y,
+		                        key_steps[offset + k1].z,
+		                        curve_radius[first_key + k1]);
+		r_keys[2] = make_float4(key_steps[offset + k2].x,
+		                        key_steps[offset + k2].y,
+		                        key_steps[offset + k2].z,
+		                        curve_radius[first_key + k2]);
+		r_keys[3] = make_float4(key_steps[offset + k3].x,
+		                        key_steps[offset + k3].y,
+		                        key_steps[offset + k3].z,
+		                        curve_radius[first_key + k3]);
+	}
+}
+
 /* SubdFace */
 
 float3 Mesh::SubdFace::normal(const Mesh *mesh) const
@@ -394,7 +651,7 @@ void Mesh::compute_bounds()
 		if(use_motion_blur && attr) {
 			size_t steps_size = verts.size() * (motion_steps - 1);
 			float3 *vert_steps = attr->data_float3();
-	
+
 			for(size_t i = 0; i < steps_size; i++)
 				bnds.grow(vert_steps[i]);
 		}
@@ -403,7 +660,7 @@ void Mesh::compute_bounds()
 		if(use_motion_blur && curve_attr) {
 			size_t steps_size = curve_keys.size() * (motion_steps - 1);
 			float3 *key_steps = curve_attr->data_float3();
-	
+
 			for(size_t i = 0; i < steps_size; i++)
 				bnds.grow(key_steps[i]);
 		}
@@ -417,11 +674,11 @@ void Mesh::compute_bounds()
 
 			for(size_t i = 0; i < curve_keys_size; i++)
 				bnds.grow_safe(curve_keys[i], curve_radius[i]);
-			
+
 			if(use_motion_blur && attr) {
 				size_t steps_size = verts.size() * (motion_steps - 1);
 				float3 *vert_steps = attr->data_float3();
-		
+
 				for(size_t i = 0; i < steps_size; i++)
 					bnds.grow_safe(vert_steps[i]);
 			}
@@ -429,7 +686,7 @@ void Mesh::compute_bounds()
 			if(use_motion_blur && curve_attr) {
 				size_t steps_size = curve_keys.size() * (motion_steps - 1);
 				float3 *key_steps = curve_attr->data_float3();
-		
+
 				for(size_t i = 0; i < steps_size; i++)
 					bnds.grow_safe(key_steps[i]);
 			}
@@ -464,7 +721,7 @@ void Mesh::add_face_normals()
 	/* don't compute if already there */
 	if(attributes.find(ATTR_STD_FACE_NORMAL))
 		return;
-	
+
 	/* get attributes */
 	Attribute *attr_fN = attributes.add(ATTR_STD_FACE_NORMAL);
 	float3 *fN = attr_fN->data_float3();
@@ -796,6 +1053,8 @@ void Mesh::compute_bvh(DeviceScene *dscene,
 			bparams.use_qbvh = params->use_qbvh;
 			bparams.use_unaligned_nodes = dscene->data.bvh.have_curves &&
 			                              params->use_bvh_unaligned_nodes;
+			bparams.num_motion_triangle_steps = params->num_bvh_time_steps;
+			bparams.num_motion_curve_steps = params->num_bvh_time_steps;
 
 			delete bvh;
 			bvh = BVH::create(bparams, objects);
@@ -1002,7 +1261,7 @@ void MeshManager::update_svm_attributes(Device *device, DeviceScene *dscene, Sce
 
 	if(attr_map_stride == 0)
 		return;
-	
+
 	/* create attribute map */
 	uint4 *attr_map = dscene->attributes_map.resize(attr_map_stride*scene->objects.size());
 	memset(attr_map, 0, dscene->attributes_map.size()*sizeof(uint));
@@ -1564,6 +1823,8 @@ void MeshManager::device_update_bvh(Device *device, DeviceScene *dscene, Scene *
 	bparams.use_spatial_split = scene->params.use_bvh_spatial_split;
 	bparams.use_unaligned_nodes = dscene->data.bvh.have_curves &&
 	                              scene->params.use_bvh_unaligned_nodes;
+	bparams.num_motion_triangle_steps = scene->params.num_bvh_time_steps;
+	bparams.num_motion_curve_steps = scene->params.num_bvh_time_steps;
 
 	delete bvh;
 	bvh = BVH::create(bparams, scene->objects);
@@ -1946,14 +2207,14 @@ bool Mesh::need_attribute(Scene *scene, AttributeStandard std)
 {
 	if(std == ATTR_STD_NONE)
 		return false;
-	
+
 	if(scene->need_global_attribute(std))
 		return true;
 
 	foreach(Shader *shader, used_shaders)
 		if(shader->attributes.find(std))
 			return true;
-	
+
 	return false;
 }
 
@@ -1965,9 +2226,8 @@ bool Mesh::need_attribute(Scene * /*scene*/, ustring name)
 	foreach(Shader *shader, used_shaders)
 		if(shader->attributes.find(name))
 			return true;
-	
+
 	return false;
 }
 
 CCL_NAMESPACE_END
-
diff --git a/intern/cycles/render/mesh.h b/intern/cycles/render/mesh.h
index c0310f45840..5f33e30eac2 100644
--- a/intern/cycles/render/mesh.h
+++ b/intern/cycles/render/mesh.h
@@ -31,6 +31,7 @@
 
 CCL_NAMESPACE_BEGIN
 
+class Attribute;
 class BVH;
 class Device;
 class DeviceScene;
@@ -54,11 +55,27 @@ public:
 		int v[3];
 
 		void bounds_grow(const float3 *verts, BoundBox& bounds) const;
+
+		void motion_verts(const float3 *verts,
+		                  const float3 *vert_steps,
+		                  size_t num_verts,
+		                  size_t num_steps,
+		                  float time,
+		                  float3 r_verts[3]) const;
+
+		void verts_for_step(const float3 *verts,
+		                    const float3 *vert_steps,
+		                    size_t num_verts,
+		                    size_t num_steps,
+		                    size_t step,
+		                    float3 r_verts[3]) const;
 	};
 
 	Triangle get_triangle(size_t i) const
 	{
-		Triangle tri = {{triangles[i*3 + 0], triangles[i*3 + 1], triangles[i*3 + 2]}};
+		Triangle tri = {{triangles[i*3 + 0],
+		                 triangles[i*3 + 1],
+		                 triangles[i*3 + 2]}};
 		return tri;
 	}
 
@@ -78,11 +95,48 @@ public:
 		                 const float3 *curve_keys,
 		                 const float *curve_radius,
 		                 BoundBox& bounds) const;
+		void bounds_grow(float4 keys[4], BoundBox& bounds) const;
 		void bounds_grow(const int k,
 		                 const float3 *curve_keys,
 		                 const float *curve_radius,
 		                 const Transform& aligned_space,
 		                 BoundBox& bounds) const;
+
+		void motion_keys(const float3 *curve_keys,
+		                 const float *curve_radius,
+		                 const float3 *key_steps,
+		                 size_t num_curve_keys,
+		                 size_t num_steps,
+		                 float time,
+		                 size_t k0, size_t k1,
+		                 float4 r_keys[2]) const;
+		void cardinal_motion_keys(const float3 *curve_keys,
+		                          const float *curve_radius,
+		                          const float3 *key_steps,
+		                          size_t num_curve_keys,
+		                          size_t num_steps,
+		                          float time,
+		                          size_t k0, size_t k1,
+		                          size_t k2, size_t k3,
+		                          float4 r_keys[4]) const;
+
+		void keys_for_step(const float3 *curve_keys,
+		                   const float *curve_radius,
+		                   const float3 *key_steps,
+		                   size_t num_curve_keys,
+		                   size_t num_steps,
+		                   size_t step,
+		                   size_t k0, size_t k1,
+		                   float4 r_keys[2]) const;
+		void cardinal_keys_for_step(const float3 *curve_keys,
+		                            const float *curve_radius,
+		                            const float3 *key_steps,
+		                            size_t num_curve_keys,
+		                            size_t num_steps,
+		                            size_t step,
+		                            size_t k0, size_t k1,
+		                            size_t k2, size_t k3,
+		                            float4 r_keys[4]) const;
 	};
 
 	Curve get_curve(size_t i) const
diff --git a/intern/cycles/render/mesh_subdivision.cpp b/intern/cycles/render/mesh_subdivision.cpp
index 913c3c74b42..57c76a9f1c8 100644
--- a/intern/cycles/render/mesh_subdivision.cpp
+++ b/intern/cycles/render/mesh_subdivision.cpp
@@ -92,7 +92,7 @@ namespace Far {
 
 			if(vert_edges.size() == 2) {
 				float sharpness = refiner.getLevel(0).getEdgeSharpness(vert_edges[0]);
-				sharpness = min(sharpness, refiner.getLevel(0).getEdgeSharpness(vert_edges[1]));
+				sharpness = ccl::min(sharpness, refiner.getLevel(0).getEdgeSharpness(vert_edges[1]));
 
 				setBaseVertexSharpness(refiner, i, sharpness);
 			}
diff --git a/intern/cycles/render/nodes.cpp b/intern/cycles/render/nodes.cpp
index c7f37a13fba..1e4a9fd300c 100644
--- a/intern/cycles/render/nodes.cpp
+++ b/intern/cycles/render/nodes.cpp
@@ -3027,6 +3027,8 @@ NODE_DEFINE(LightPathNode)
 	SOCKET_OUT_FLOAT(is_volume_scatter_ray, "Is Volume Scatter Ray");
 	SOCKET_OUT_FLOAT(ray_length, "Ray Length");
 	SOCKET_OUT_FLOAT(ray_depth, "Ray Depth");
+	SOCKET_OUT_FLOAT(diffuse_depth, "Diffuse Depth");
+	SOCKET_OUT_FLOAT(glossy_depth, "Glossy Depth");
 	SOCKET_OUT_FLOAT(transparent_depth, "Transparent Depth");
 	SOCKET_OUT_FLOAT(transmission_depth, "Transmission Depth");
 
@@ -3093,6 +3095,16 @@ void LightPathNode::compile(SVMCompiler& compiler)
 		compiler.add_node(NODE_LIGHT_PATH, NODE_LP_ray_depth, compiler.stack_assign(out));
 	}
 
+	out = output("Diffuse Depth");
+	if(!out->links.empty()) {
+		compiler.add_node(NODE_LIGHT_PATH, NODE_LP_ray_diffuse, compiler.stack_assign(out));
+	}
+
+	out = output("Glossy Depth");
+	if(!out->links.empty()) {
+		compiler.add_node(NODE_LIGHT_PATH, NODE_LP_ray_glossy, compiler.stack_assign(out));
+	}
+
 	out = output("Transparent Depth");
 	if(!out->links.empty()) {
 		compiler.add_node(NODE_LIGHT_PATH, NODE_LP_ray_transparent, compiler.stack_assign(out));
diff --git a/intern/cycles/render/object.cpp b/intern/cycles/render/object.cpp
index 8b8b988b969..c592b62829e 100644
--- a/intern/cycles/render/object.cpp
+++ b/intern/cycles/render/object.cpp
@@ -166,7 +166,7 @@ void Object::apply_transform(bool apply_to_motion)
 		float3 c0 = transform_get_column(&tfm, 0);
 		float3 c1 = transform_get_column(&tfm, 1);
 		float3 c2 = transform_get_column(&tfm, 2);
-		float scalar = pow(fabsf(dot(cross(c0, c1), c2)), 1.0f/3.0f);
+		float scalar = powf(fabsf(dot(cross(c0, c1), c2)), 1.0f/3.0f);
 
 		/* apply transform to curve keys */
 		for(size_t i = 0; i < mesh->curve_keys.size(); i++) {
diff --git a/intern/cycles/render/scene.h b/intern/cycles/render/scene.h
index df9363cc768..8768682043f 100644
--- a/intern/cycles/render/scene.h
+++ b/intern/cycles/render/scene.h
@@ -143,6 +143,7 @@ public:
 	} bvh_type;
 	bool use_bvh_spatial_split;
 	bool use_bvh_unaligned_nodes;
+	int num_bvh_time_steps;
 	bool use_qbvh;
 	bool persistent_data;
 	int texture_limit;
@@ -153,6 +154,7 @@ public:
 		bvh_type = BVH_DYNAMIC;
 		use_bvh_spatial_split = false;
 		use_bvh_unaligned_nodes = true;
+		num_bvh_time_steps = 0;
 		use_qbvh = false;
 		persistent_data = false;
 		texture_limit = 0;
@@ -163,6 +165,7 @@ public:
 		&& bvh_type == params.bvh_type
 		&& use_bvh_spatial_split == params.use_bvh_spatial_split
 		&& use_bvh_unaligned_nodes == params.use_bvh_unaligned_nodes
+		&& num_bvh_time_steps == params.num_bvh_time_steps
 		&& use_qbvh == params.use_qbvh
 		&& persistent_data == params.persistent_data
 		&& texture_limit == params.texture_limit); }
diff --git a/intern/cycles/render/session.cpp b/intern/cycles/render/session.cpp
index 73caf93ea00..7c01934cfd8 100644
--- a/intern/cycles/render/session.cpp
+++ b/intern/cycles/render/session.cpp
@@ -458,6 +458,8 @@ void Session::release_tile(RenderTile& rtile)
 {
 	thread_scoped_lock tile_lock(tile_mutex);
 
+	progress.add_finished_tile();
+
 	if(write_render_tile_cb) {
 		if(params.progressive_refine == false) {
 			/* todo: optimize this by making it thread safe and removing lock */
diff --git a/intern/cycles/util/util_boundbox.h b/intern/cycles/util/util_boundbox.h
index 599222da9c5..dfe4977aef3 100644
--- a/intern/cycles/util/util_boundbox.h
+++ b/intern/cycles/util/util_boundbox.h
@@ -25,8 +25,6 @@
 #include "util_transform.h"
 #include "util_types.h"
 
-using namespace std;
-
 CCL_NAMESPACE_BEGIN
 
 /* 3D BoundBox */
diff --git a/intern/cycles/util/util_math.h b/intern/cycles/util/util_math.h
index 6cb68b53d16..2b81c8c498a 100644
--- a/intern/cycles/util/util_math.h
+++ b/intern/cycles/util/util_math.h
@@ -22,6 +22,11 @@
  * Basic math functions on scalar and vector types. This header is used by
  * both the kernel code when compiled as C++, and other C++ non-kernel code. */
 
+#ifndef __KERNEL_GPU__
+#  include <cmath>
+#endif
+
+
 #ifndef __KERNEL_OPENCL__
 
 #include <float.h>
@@ -97,6 +102,9 @@ ccl_device_inline float fminf(float a, float b)
 
 #ifndef __KERNEL_GPU__
 
+using std::isfinite;
+using std::isnan;
+
 ccl_device_inline int abs(int x)
 {
 	return (x > 0)? x: -x;
@@ -1233,6 +1241,20 @@ ccl_device_inline float __uint_as_float(uint i)
 	return u.f;
 }
 
+/* Versions of functions which are safe for fast math. */
+ccl_device_inline bool isnan_safe(float f)
+{
+	unsigned int x = __float_as_uint(f);
+	return (x << 1) > 0xff000000u;
+}
+
+ccl_device_inline bool isfinite_safe(float f)
+{
+	/* By IEEE 754 rule, 2*Inf equals Inf */
+	unsigned int x = __float_as_uint(f);
+	return (f == f) && (x == 0 || (f != 2.0f*f));
+}
+
 /* Interpolation */
 
 template<class A, class B> A lerp(const A& a, const A& b, const B& t)
diff --git a/make.bat b/make.bat
index f3ec646dc8f..c73101d1430 100644
--- a/make.bat
+++ b/make.bat
@@ -129,9 +129,6 @@ if "%BUILD_ARCH%"=="x64" (
 )
 
 
-set BUILD_DIR=%BUILD_DIR%_%TARGET%_%BUILD_ARCH%_vc%BUILD_VS_VER%_%BUILD_TYPE%
-
-
 if "%target%"=="Release" (
 		rem for vc12 check for both cuda 7.5 and 8 
 		if "%CUDA_PATH%"=="" (
@@ -173,7 +170,7 @@ where /Q msbuild
 if %ERRORLEVEL% NEQ 0 (
 	if "%BUILD_VS_VER%"=="12" (
 		rem vs12 not found, try vs14
-		echo Visual Studio 2012 not found, trying Visual Studio 2015.
+		echo Visual Studio 2013 not found, trying Visual Studio 2015.
 		set BUILD_VS_VER=14
 		set BUILD_VS_YEAR=2015
 		goto DetectMSVC
@@ -184,6 +181,11 @@ if %ERRORLEVEL% NEQ 0 (
 		goto EOF
 	)
 )
+
+
+set BUILD_DIR=%BUILD_DIR%_%TARGET%_%BUILD_ARCH%_vc%BUILD_VS_VER%_%BUILD_TYPE%
+
+
 where /Q cmake
 if %ERRORLEVEL% NEQ 0 (
 	echo Error: "CMake" command not in the PATH.
diff --git a/release/scripts/startup/bl_ui/properties_animviz.py b/release/scripts/startup/bl_ui/properties_animviz.py
index 11081232f12..046b5eb2aa5 100644
--- a/release/scripts/startup/bl_ui/properties_animviz.py
+++ b/release/scripts/startup/bl_ui/properties_animviz.py
@@ -86,8 +86,12 @@ class MotionPathButtonsPanel:
         col = split.column()
         col.label(text="Show:")
         col.prop(mps, "show_frame_numbers", text="Frame Numbers")
+        if mpath is not None:
+            col.prop(mpath, "lines", text='Lines')
+            col.prop(mpath, "line_thickness", text='Thickness')
 
         col = split.column()
+        col.label('')
         col.prop(mps, "show_keyframe_highlight", text="Keyframes")
         sub = col.column()
         sub.enabled = mps.show_keyframe_highlight
@@ -95,6 +99,14 @@ class MotionPathButtonsPanel:
             sub.prop(mps, "show_keyframe_action_all", text="+ Non-Grouped Keyframes")
         sub.prop(mps, "show_keyframe_numbers", text="Keyframe Numbers")
 
+        # Customize path
+        if mpath is not None:
+            row = layout.row(align=True)
+            row.prop(mpath, "use_custom_color", text='', toggle=True, icon='COLOR')
+            sub = row.row(align=True)
+            sub.enabled = mpath.use_custom_color
+            sub.prop(mpath, "color", text='')
+
 
 # FIXME: this panel still needs to be ported so that it will work correctly with animviz
 class OnionSkinButtonsPanel:
diff --git a/release/scripts/startup/bl_ui/properties_game.py b/release/scripts/startup/bl_ui/properties_game.py
index 98b7a76e541..4d54817a21c 100644
--- a/release/scripts/startup/bl_ui/properties_game.py
+++ b/release/scripts/startup/bl_ui/properties_game.py
@@ -714,7 +714,7 @@ class WORLD_PT_game_physics(WorldButtonsPanel, Panel):
 
 
 class WORLD_PT_game_physics_obstacles(WorldButtonsPanel, Panel):
-    bl_label = "Obstacle simulation"
+    bl_label = "Obstacle Simulation"
     COMPAT_ENGINES = {'BLENDER_GAME'}
 
     @classmethod
diff --git a/release/scripts/startup/bl_ui/properties_grease_pencil_common.py b/release/scripts/startup/bl_ui/properties_grease_pencil_common.py
index f8ee7c9a851..4529c127839 100644
--- a/release/scripts/startup/bl_ui/properties_grease_pencil_common.py
+++ b/release/scripts/startup/bl_ui/properties_grease_pencil_common.py
@@ -115,6 +115,12 @@ class GreasePencilDrawingToolsPanel:
         row.operator("gpencil.draw", icon='LINE_DATA', text="Line").mode = 'DRAW_STRAIGHT'
         row.operator("gpencil.draw", icon='MESH_DATA', text="Poly").mode = 'DRAW_POLY'
 
+        col.separator()
+
+        sub = col.column(align=True)
+        sub.operator("gpencil.blank_frame_add", icon='NEW')
+        sub.operator("gpencil.active_frames_delete_all", icon='X', text="Delete Frame(s)")
+
         sub = col.column(align=True)
         sub.prop(context.tool_settings, "use_gpencil_additive_drawing", text="Additive Drawing")
         sub.prop(context.tool_settings, "use_gpencil_continuous_drawing", text="Continuous Drawing")
@@ -227,12 +233,7 @@ class GreasePencilStrokeEditPanel:
 
         if is_3d_view:
             layout.separator()
-            col = layout.column(align=True)
-            col.operator("gpencil.interpolate", text="Interpolate")
-            col.operator("gpencil.interpolate_sequence", text="Sequence")
-            settings = context.tool_settings.gpencil_sculpt
-            col.prop(settings, "interpolate_all_layers")
-            col.prop(settings, "interpolate_selected_only")
+            
 
         layout.separator()
         col = layout.column(align=True)
@@ -247,7 +248,57 @@ class GreasePencilStrokeEditPanel:
 
         if is_3d_view:
             layout.separator()
-            layout.operator("gpencil.reproject")
+            layout.operator_menu_enum("gpencil.reproject", text="Reproject Strokes...", property="type")
+
+
+class GreasePencilInterpolatePanel:
+    bl_space_type = 'VIEW_3D'
+    bl_label = "Interpolate"
+    bl_category = "Grease Pencil"
+    bl_region_type = 'TOOLS'
+    bl_options = {'DEFAULT_CLOSED'}
+
+    @classmethod
+    def poll(cls, context):
+        if context.gpencil_data is None:
+            return False
+        elif context.space_data.type != 'VIEW_3D':
+            return False
+
+        gpd = context.gpencil_data
+        return bool(context.editable_gpencil_strokes) and bool(gpd.use_stroke_edit_mode)
+
+    @staticmethod
+    def draw(self, context):
+        layout = self.layout
+        settings = context.tool_settings.gpencil_interpolate
+
+        col = layout.column(align=True)
+        col.operator("gpencil.interpolate", text="Interpolate")
+        col.operator("gpencil.interpolate_sequence", text="Sequence")
+        col.operator("gpencil.interpolate_reverse", text="Remove Breakdowns")
+
+        col = layout.column(align=True)
+        col.label(text="Options:")
+        col.prop(settings, "interpolate_all_layers")
+        col.prop(settings, "interpolate_selected_only")
+
+        col = layout.column(align=True)
+        col.label(text="Sequence Options:")
+        col.prop(settings, "type")
+        if settings.type == 'CUSTOM':
+            box = layout.box()
+            # TODO: Options for loading/saving curve presets?
+            box.template_curve_mapping(settings, "interpolation_curve", brush=True)
+        elif settings.type != 'LINEAR':
+            col.prop(settings, "easing")
+
+            if settings.type == 'BACK':
+                layout.prop(settings, "back")
+            elif setting.type == 'ELASTIC':
+                sub = layout.column(align=True)
+                sub.prop(settings, "amplitude")
+                sub.prop(settings, "period")
 
 
 class GreasePencilBrushPanel:
diff --git a/release/scripts/startup/bl_ui/space_view3d_toolbar.py b/release/scripts/startup/bl_ui/space_view3d_toolbar.py
index 3eb76a3b0f9..60e86d7544d 100644
--- a/release/scripts/startup/bl_ui/space_view3d_toolbar.py
+++ b/release/scripts/startup/bl_ui/space_view3d_toolbar.py
@@ -22,6 +22,7 @@ from bpy.types import Menu, Panel, UIList
 from bl_ui.properties_grease_pencil_common import (
         GreasePencilDrawingToolsPanel,
         GreasePencilStrokeEditPanel,
+        GreasePencilInterpolatePanel,
         GreasePencilStrokeSculptPanel,
         GreasePencilBrushPanel,
         GreasePencilBrushCurvesPanel
@@ -1963,6 +1964,11 @@ class VIEW3D_PT_tools_grease_pencil_edit(GreasePencilStrokeEditPanel, Panel):
     bl_space_type = 'VIEW_3D'
 
 
+# Grease Pencil stroke interpolation tools
+class VIEW3D_PT_tools_grease_pencil_interpolate(GreasePencilInterpolatePanel, Panel):
+    bl_space_type = 'VIEW_3D'
+
+
 # Grease Pencil stroke sculpting tools
 class VIEW3D_PT_tools_grease_pencil_sculpt(GreasePencilStrokeSculptPanel, Panel):
     bl_space_type = 'VIEW_3D'
diff --git a/release/scripts/startup/nodeitems_builtins.py b/release/scripts/startup/nodeitems_builtins.py
index 69358302782..e915aa5bb72 100644
--- a/release/scripts/startup/nodeitems_builtins.py
+++ b/release/scripts/startup/nodeitems_builtins.py
@@ -145,6 +145,7 @@ shader_node_categories = [
         NodeItem("ShaderNodeMaterial"),
         NodeItem("ShaderNodeCameraData"),
         NodeItem("ShaderNodeFresnel"),
+        NodeItem("ShaderNodeLayerWeight"),
         NodeItem("ShaderNodeLampData"),
         NodeItem("ShaderNodeValue"),
         NodeItem("ShaderNodeRGB"),
diff --git a/source/blender/blenkernel/intern/anim.c b/source/blender/blenkernel/intern/anim.c
index 7d3d12ac112..2f65e71c6d2 100644
--- a/source/blender/blenkernel/intern/anim.c
+++ b/source/blender/blenkernel/intern/anim.c
@@ -201,7 +201,15 @@ bMotionPath *animviz_verify_motionpaths(ReportList *reports, Scene *scene, Objec
 		mpath->flag |= MOTIONPATH_FLAG_BHEAD;
 	else
 		mpath->flag &= ~MOTIONPATH_FLAG_BHEAD;
-	
+
+	/* set default custom values */
+	mpath->color[0] = 1.0;    /* Red */
+	mpath->color[1] = 0.0;
+	mpath->color[2] = 0.0;
+
+	mpath->line_thickness = 1;
+	mpath->flag |= MOTIONPATH_FLAG_LINES;  /* draw lines by default */
+
 	/* allocate a cache */
 	mpath->points = MEM_callocN(sizeof(bMotionPathVert) * mpath->length, "bMotionPathVerts");
 	
diff --git a/source/blender/blenkernel/intern/armature.c b/source/blender/blenkernel/intern/armature.c
index 2b333941c6e..0287d6ae9ca 100644
--- a/source/blender/blenkernel/intern/armature.c
+++ b/source/blender/blenkernel/intern/armature.c
@@ -87,6 +87,7 @@ bArmature *BKE_armature_add(Main *bmain, const char *name)
 	arm->deformflag = ARM_DEF_VGROUP | ARM_DEF_ENVELOPE;
 	arm->flag = ARM_COL_CUSTOM; /* custom bone-group colors */
 	arm->layer = 1;
+	arm->ghostsize = 1;
 	return arm;
 }
 
diff --git a/source/blender/blenkernel/intern/library.c b/source/blender/blenkernel/intern/library.c
index 51015abf4ad..de35d1e0eac 100644
--- a/source/blender/blenkernel/intern/library.c
+++ b/source/blender/blenkernel/intern/library.c
@@ -1408,7 +1408,8 @@ static ID *is_dupid(ListBase *lb, ID *id, const char *name)
 static bool check_for_dupid(ListBase *lb, ID *id, char *name)
 {
 	ID *idtest;
-	int nr = 0, a, left_len;
+	int nr = 0, a;
+	size_t left_len;
 #define MAX_IN_USE 64
 	bool in_use[MAX_IN_USE];
 	/* to speed up finding unused numbers within [1 .. MAX_IN_USE - 1] */
@@ -1442,7 +1443,7 @@ static bool check_for_dupid(ListBase *lb, ID *id, char *name)
 
 		/* Code above may have generated invalid utf-8 string, due to raw truncation.
 		 * Ensure we get a valid one now! */
-		left_len -= BLI_utf8_invalid_strip(left, left_len);
+		left_len -= (size_t)BLI_utf8_invalid_strip(left, left_len);
 
 		for (idtest = lb->first; idtest; idtest = idtest->next) {
 			int nrtest;
@@ -1484,7 +1485,7 @@ static bool check_for_dupid(ListBase *lb, ID *id, char *name)
 		 * shave off the end chars until we have a unique name.
 		 * Check the null terminators match as well so we don't get Cube.000 -> Cube.00 */
 		if (nr == 0 && name[left_len] == '\0') {
-			int len;
+			size_t len;
 			/* FIXME: this code will never be executed, because either nr will be
 			 * at least 1, or name will not end at left_len! */
 			BLI_assert(0);
diff --git a/source/blender/blenkernel/intern/scene.c b/source/blender/blenkernel/intern/scene.c
index 39a97b08df1..69d3b4db54c 100644
--- a/source/blender/blenkernel/intern/scene.c
+++ b/source/blender/blenkernel/intern/scene.c
@@ -287,13 +287,16 @@ Scene *BKE_scene_copy(Main *bmain, Scene *sce, int type)
 		ts->imapaint.paintcursor = NULL;
 		id_us_plus((ID *)ts->imapaint.stencil);
 		ts->particle.paintcursor = NULL;
+		
 		/* duplicate Grease Pencil Drawing Brushes */
 		BLI_listbase_clear(&ts->gp_brushes);
 		for (bGPDbrush *brush = sce->toolsettings->gp_brushes.first; brush; brush = brush->next) {
 			bGPDbrush *newbrush = BKE_gpencil_brush_duplicate(brush);
 			BLI_addtail(&ts->gp_brushes, newbrush);
 		}
-
+		
+		/* duplicate Grease Pencil interpolation curve */
+		ts->gp_interpolate.custom_ipo = curvemapping_copy(ts->gp_interpolate.custom_ipo);
 	}
 	
 	/* make a private copy of the avicodecdata */
@@ -440,12 +443,17 @@ void BKE_scene_free(Scene *sce)
 			BKE_paint_free(&sce->toolsettings->uvsculpt->paint);
 			MEM_freeN(sce->toolsettings->uvsculpt);
 		}
+		BKE_paint_free(&sce->toolsettings->imapaint.paint);
+		
 		/* free Grease Pencil Drawing Brushes */
 		BKE_gpencil_free_brushes(&sce->toolsettings->gp_brushes);
 		BLI_freelistN(&sce->toolsettings->gp_brushes);
-
-		BKE_paint_free(&sce->toolsettings->imapaint.paint);
-
+		
+		/* free Grease Pencil interpolation curve */
+		if (sce->toolsettings->gp_interpolate.custom_ipo) {
+			curvemapping_free(sce->toolsettings->gp_interpolate.custom_ipo);
+		}
+		
 		MEM_freeN(sce->toolsettings);
 		sce->toolsettings = NULL;
 	}
diff --git a/source/blender/blenkernel/intern/text.c b/source/blender/blenkernel/intern/text.c
index 672857e88fe..88575c7d3be 100644
--- a/source/blender/blenkernel/intern/text.c
+++ b/source/blender/blenkernel/intern/text.c
@@ -235,8 +235,9 @@ Text *BKE_text_add(Main *bmain, const char *name)
 /* to a valid utf-8 sequences */
 int txt_extended_ascii_as_utf8(char **str)
 {
-	int bad_char, added = 0, i = 0;
-	int length = strlen(*str);
+	ptrdiff_t bad_char, i = 0;
+	const ptrdiff_t length = (ptrdiff_t)strlen(*str);
+	int added = 0;
 
 	while ((*str)[i]) {
 		if ((bad_char = BLI_utf8_invalid_byte(*str + i, length - i)) == -1)
@@ -248,7 +249,7 @@ int txt_extended_ascii_as_utf8(char **str)
 	
 	if (added != 0) {
 		char *newstr = MEM_mallocN(length + added + 1, "text_line");
-		int mi = 0;
+		ptrdiff_t mi = 0;
 		i = 0;
 		
 		while ((*str)[i]) {
diff --git a/source/blender/blenkernel/intern/tracking_util.c b/source/blender/blenkernel/intern/tracking_util.c
index c34da4f6814..1c056cda68d 100644
--- a/source/blender/blenkernel/intern/tracking_util.c
+++ b/source/blender/blenkernel/intern/tracking_util.c
@@ -625,17 +625,17 @@ static ImBuf *make_grayscale_ibuf_copy(ImBuf *ibuf)
 	 */
 	size = (size_t)grayscale->x * (size_t)grayscale->y * sizeof(float);
 	grayscale->channels = 1;
-	if ((grayscale->rect_float = MEM_mapallocN(size, "tracking grayscale image"))) {
+	if ((grayscale->rect_float = MEM_mapallocN(size, "tracking grayscale image")) != NULL) {
 		grayscale->mall |= IB_rectfloat;
 		grayscale->flags |= IB_rectfloat;
-	}
 
-	for (i = 0; i < grayscale->x * grayscale->y; ++i) {
-		const float *pixel = ibuf->rect_float + ibuf->channels * i;
+		for (i = 0; i < grayscale->x * grayscale->y; ++i) {
+			const float *pixel = ibuf->rect_float + ibuf->channels * i;
 
-		grayscale->rect_float[i] = 0.2126f * pixel[0] +
-		                           0.7152f * pixel[1] +
-		                           0.0722f * pixel[2];
+			grayscale->rect_float[i] = 0.2126f * pixel[0] +
+			                           0.7152f * pixel[1] +
+			                           0.0722f * pixel[2];
+		}
 	}
 
 	return grayscale;
@@ -653,14 +653,14 @@ static void ibuf_to_float_image(const ImBuf *ibuf, libmv_FloatImage *float_image
 static ImBuf *float_image_to_ibuf(libmv_FloatImage *float_image)
 {
 	ImBuf *ibuf = IMB_allocImBuf(float_image->width, float_image->height, 32, 0);
-	size_t size = (size_t)ibuf->x * (size_t)ibuf->y *
-	              float_image->channels * sizeof(float);
+	size_t size = (size_t)ibuf->x * (size_t)ibuf->y * float_image->channels * sizeof(float);
 	ibuf->channels = float_image->channels;
-	if ((ibuf->rect_float = MEM_mapallocN(size, "tracking grayscale image"))) {
+	if ((ibuf->rect_float = MEM_mapallocN(size, "tracking grayscale image")) != NULL) {
 		ibuf->mall |= IB_rectfloat;
 		ibuf->flags |= IB_rectfloat;
+
+		memcpy(ibuf->rect_float, float_image->buffer, size);
 	}
-	memcpy(ibuf->rect_float, float_image->buffer, size);
 	return ibuf;
 }
 
diff --git a/source/blender/blenlib/BLI_string_utf8.h b/source/blender/blenlib/BLI_string_utf8.h
index 0740b574c1a..32504a88b48 100644
--- a/source/blender/blenlib/BLI_string_utf8.h
+++ b/source/blender/blenlib/BLI_string_utf8.h
@@ -36,8 +36,8 @@ extern "C" {
 char        *BLI_strncpy_utf8(char *__restrict dst, const char *__restrict src, size_t maxncpy) ATTR_NONNULL();
 size_t       BLI_strncpy_utf8_rlen(char *__restrict dst, const char *__restrict src, size_t maxncpy) ATTR_NONNULL();
 char        *BLI_strncat_utf8(char *__restrict dst, const char *__restrict src, size_t maxncpy) ATTR_NONNULL();
-int          BLI_utf8_invalid_byte(const char *str, int length) ATTR_NONNULL();
-int          BLI_utf8_invalid_strip(char *str, int length) ATTR_NONNULL();
+ptrdiff_t    BLI_utf8_invalid_byte(const char *str, size_t length) ATTR_NONNULL();
+int          BLI_utf8_invalid_strip(char *str, size_t length) ATTR_NONNULL();
 
 int          BLI_str_utf8_size(const char *p) ATTR_NONNULL(); /* warning, can return -1 on bad chars */
 int          BLI_str_utf8_size_safe(const char *p) ATTR_NONNULL();
diff --git a/source/blender/blenlib/BLI_string_utils.h b/source/blender/blenlib/BLI_string_utils.h
index 719d6e3c57b..bb19ed574bb 100644
--- a/source/blender/blenlib/BLI_string_utils.h
+++ b/source/blender/blenlib/BLI_string_utils.h
@@ -44,7 +44,7 @@ struct ListBase;
 
 typedef bool (*UniquenameCheckCallback)(void *arg, const char *name);
 
-int BLI_split_name_num(char *left, int *nr, const char *name, const char delim);
+size_t BLI_split_name_num(char *left, int *nr, const char *name, const char delim);
 
 void BLI_string_split_suffix(const char *string, char *r_body, char *r_suf, const size_t str_len);
 void BLI_string_split_prefix(const char *string, char *r_pre, char *r_body, const size_t str_len);
diff --git a/source/blender/blenlib/intern/string_utf8.c b/source/blender/blenlib/intern/string_utf8.c
index 0ab11810b48..83d4a75952f 100644
--- a/source/blender/blenlib/intern/string_utf8.c
+++ b/source/blender/blenlib/intern/string_utf8.c
@@ -74,7 +74,7 @@ static const size_t utf8_skip_data[256] = {
  *
  * \return the offset of the first invalid byte.
  */
-int BLI_utf8_invalid_byte(const char *str, int length)
+ptrdiff_t BLI_utf8_invalid_byte(const char *str, size_t length)
 {
 	const unsigned char *p, *perr, *pend = (const unsigned char *)str + length;
 	unsigned char c;
@@ -161,18 +161,24 @@ int BLI_utf8_invalid_byte(const char *str, int length)
 
 utf8_error:
 
-	return (int)((const char *)perr - (const char *)str);
+	return ((const char *)perr - (const char *)str);
 }
 
-int BLI_utf8_invalid_strip(char *str, int length)
+/**
+ * Remove any invalid utf-8 byte (taking into account multi-bytes sequence of course).
+ *
+ * @return number of stripped bytes.
+ */
+int BLI_utf8_invalid_strip(char *str, size_t length)
 {
-	int bad_char, tot = 0;
+	ptrdiff_t bad_char;
+	int tot = 0;
 
 	BLI_assert(str[length] == '\0');
 
 	while ((bad_char = BLI_utf8_invalid_byte(str, length)) != -1) {
 		str += bad_char;
-		length -= (bad_char + 1);
+		length -= (size_t)(bad_char + 1);
 
 		if (length == 0) {
 			/* last character bad, strip it */
@@ -182,7 +188,7 @@ int BLI_utf8_invalid_strip(char *str, int length)
 		}
 		else {
 			/* strip, keep looking */
-			memmove(str, str + 1, (size_t)length + 1);  /* +1 for NULL char! */
+			memmove(str, str + 1, length + 1);  /* +1 for NULL char! */
 			tot++;
 		}
 	}
diff --git a/source/blender/blenlib/intern/string_utils.c b/source/blender/blenlib/intern/string_utils.c
index 435a88d6e21..8d91a55a5ad 100644
--- a/source/blender/blenlib/intern/string_utils.c
+++ b/source/blender/blenlib/intern/string_utils.c
@@ -61,7 +61,7 @@
  * \param delim  Delimiter character
  * \return  Length of \a left
  */
-int BLI_split_name_num(char *left, int *nr, const char *name, const char delim)
+size_t BLI_split_name_num(char *left, int *nr, const char *name, const char delim)
 {
 	const size_t name_len = strlen(name);
 
@@ -70,7 +70,7 @@ int BLI_split_name_num(char *left, int *nr, const char *name, const char delim)
 
 	/* name doesn't end with a delimiter "foo." */
 	if ((name_len > 1 && name[name_len - 1] == delim) == 0) {
-		int a = name_len;
+		size_t a = name_len;
 		while (a--) {
 			if (name[a] == delim) {
 				left[a] = '\0';  /* truncate left part here */
@@ -295,7 +295,7 @@ bool BLI_uniquename_cb(
 		char *tempname = alloca(name_len);
 		char *left = alloca(name_len);
 		int number;
-		int len = BLI_split_name_num(left, &number, name, delim);
+		size_t len = BLI_split_name_num(left, &number, name, delim);
 		do {
 			/* add 1 to account for \0 */
 			const size_t numlen = BLI_snprintf(numstr, sizeof(numstr), "%c%03d", delim, ++number) + 1;
diff --git a/source/blender/blenloader/intern/readfile.c b/source/blender/blenloader/intern/readfile.c
index 0e1861abcf1..1230a535fef 100644
--- a/source/blender/blenloader/intern/readfile.c
+++ b/source/blender/blenloader/intern/readfile.c
@@ -5932,6 +5932,7 @@ static void direct_link_scene(FileData *fd, Scene *sce)
 			sce->toolsettings->wpaint->wpaint_prev = NULL;
 			sce->toolsettings->wpaint->tot = 0;
 		}
+		
 		/* relink grease pencil drawing brushes */
 		link_list(fd, &sce->toolsettings->gp_brushes);
 		for (bGPDbrush *brush = sce->toolsettings->gp_brushes.first; brush; brush = brush->next) {
@@ -5948,6 +5949,12 @@ static void direct_link_scene(FileData *fd, Scene *sce)
 				direct_link_curvemapping(fd, brush->cur_jitter);
 			}
 		}
+		
+		/* relink grease pencil interpolation curves */
+		sce->toolsettings->gp_interpolate.custom_ipo = newdataadr(fd, sce->toolsettings->gp_interpolate.custom_ipo);
+		if (sce->toolsettings->gp_interpolate.custom_ipo) {
+			direct_link_curvemapping(fd, sce->toolsettings->gp_interpolate.custom_ipo);
+		}
 	}
 
 	if (sce->ed) {
diff --git a/source/blender/blenloader/intern/versioning_270.c b/source/blender/blenloader/intern/versioning_270.c
index ea654ad6906..58cc06ddec6 100644
--- a/source/blender/blenloader/intern/versioning_270.c
+++ b/source/blender/blenloader/intern/versioning_270.c
@@ -1474,6 +1474,36 @@ void blo_do_versions_270(FileData *fd, Library *UNUSED(lib), Main *main)
 		for (Brush *br = main->brush.first; br; br = br->id.next) {
 			br->fill_threshold /= sqrt_3;
 		}
+
+		/* Custom motion paths */
+		if (!DNA_struct_elem_find(fd->filesdna, "bMotionPath", "int", "line_thickness")) {
+			Object *ob;
+			for (ob = main->object.first; ob; ob = ob->id.next) {
+				bMotionPath *mpath;
+				bPoseChannel *pchan;
+				mpath = ob->mpath;
+				if (mpath) {
+					mpath->color[0] = 1.0f;
+					mpath->color[1] = 0.0f;
+					mpath->color[2] = 0.0f;
+					mpath->line_thickness = 1;
+					mpath->flag |= MOTIONPATH_FLAG_LINES;
+				}
+				/* bones motion path */
+				if (ob->pose) {
+					for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
+						mpath = pchan->mpath;
+						if (mpath) {
+							mpath->color[0] = 1.0f;
+							mpath->color[1] = 0.0f;
+							mpath->color[2] = 0.0f;
+							mpath->line_thickness = 1;
+							mpath->flag |= MOTIONPATH_FLAG_LINES;
+						}
+					}
+				}
+			}
+		}
 	}
 
 	/* To be added to next subversion bump! */
diff --git a/source/blender/blenloader/intern/writefile.c b/source/blender/blenloader/intern/writefile.c
index 27db83055bb..8ba36d149e6 100644
--- a/source/blender/blenloader/intern/writefile.c
+++ b/source/blender/blenloader/intern/writefile.c
@@ -2690,6 +2690,10 @@ static void write_scenes(WriteData *wd, ListBase *scebase)
 				write_curvemapping(wd, brush->cur_jitter);
 			}
 		}
+		/* write grease-pencil custom ipo curve to file */
+		if (tos->gp_interpolate.custom_ipo) {
+			write_curvemapping(wd, tos->gp_interpolate.custom_ipo);
+		}
 		
 
 		write_paint(wd, &tos->imapaint.paint);
diff --git a/source/blender/bmesh/intern/bmesh_construct.c b/source/blender/bmesh/intern/bmesh_construct.c
index 132a7ccd4fa..e46a31cb2e9 100644
--- a/source/blender/bmesh/intern/bmesh_construct.c
+++ b/source/blender/bmesh/intern/bmesh_construct.c
@@ -387,15 +387,11 @@ BMFace *BM_face_create_ngon_verts(
  *
  * \note Since this is a vcloud there is no direction.
  */
-BMFace *BM_face_create_ngon_vcloud(
-        BMesh *bm, BMVert **vert_arr, int len,
-        const BMFace *f_example, const eBMCreateFlag create_flag)
+void BM_verts_sort_radial_plane(BMVert **vert_arr, int len)
 {
 	struct SortIntByFloat *vang = BLI_array_alloca(vang, len);
 	BMVert **vert_arr_map = BLI_array_alloca(vert_arr_map, len);
 
-	BMFace *f;
-
 	float totv_inv = 1.0f / (float)len;
 	int i = 0;
 
@@ -470,26 +466,9 @@ BMFace *BM_face_create_ngon_vcloud(
 
 	/* now calculate every points angle around the normal (signed) */
 	for (i = 0; i < len; i++) {
-		float co[3];
-		float proj_vec[3];
-		float angle;
-
-		/* center relative vec */
-		sub_v3_v3v3(co, vert_arr[i]->co, cent);
-
-		/* align to plane */
-		project_v3_v3v3(proj_vec, co, nor);
-		sub_v3_v3(co, proj_vec);
-
-		/* now 'co' is valid - we can compare its angle against the far vec */
-		angle = angle_v3v3(far_vec, co);
-
-		if (dot_v3v3(co, sign_vec) < 0.0f) {
-			angle = -angle;
-		}
-
-		vang[i].sort_value = angle;
+		vang[i].sort_value = angle_signed_on_axis_v3v3v3_v3(far, cent, vert_arr[i]->co, nor);
 		vang[i].data = i;
+		vert_arr_map[i] = vert_arr[i];
 	}
 
 	/* sort by angle and magic! - we have our ngon */
@@ -497,14 +476,9 @@ BMFace *BM_face_create_ngon_vcloud(
 
 	/* --- */
 
-	/* create edges and find the winding (if faces are attached to any existing edges) */
 	for (i = 0; i < len; i++) {
-		vert_arr_map[i] = vert_arr[vang[i].data];
+		vert_arr[i] = vert_arr_map[vang[i].data];
 	}
-
-	f = BM_face_create_ngon_verts(bm, vert_arr_map, len, f_example, create_flag, true, true);
-
-	return f;
 }
 
 /*************************************************************/
diff --git a/source/blender/bmesh/intern/bmesh_construct.h b/source/blender/bmesh/intern/bmesh_construct.h
index 9c6483de42b..a52a17cd2f3 100644
--- a/source/blender/bmesh/intern/bmesh_construct.h
+++ b/source/blender/bmesh/intern/bmesh_construct.h
@@ -34,6 +34,9 @@ bool BM_verts_from_edges(BMVert **vert_arr, BMEdge **edge_arr, const int len);
 bool BM_edges_from_verts(BMEdge **edge_arr, BMVert **vert_arr, const int len);
 void BM_edges_from_verts_ensure(BMesh *bm, BMEdge **edge_arr, BMVert **vert_arr, const int len);
 
+/* sort before creation */
+void    BM_verts_sort_radial_plane(BMVert **vert_arr, int len);
+
 BMFace *BM_face_create_quad_tri(
         BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v3, BMVert *v4,
         const BMFace *f_example, const eBMCreateFlag create_flag);
@@ -50,10 +53,6 @@ BMFace *BM_face_create_ngon_verts(
         const BMFace *f_example, const eBMCreateFlag create_flag,
         const bool calc_winding, const bool create_edges);
 
-BMFace *BM_face_create_ngon_vcloud(
-        BMesh *bm, BMVert **vert_arr, int len,
-        const BMFace *f_example, const eBMCreateFlag create_flag);
-
 void BM_elem_attrs_copy_ex(
         BMesh *bm_src, BMesh *bm_dst, const void *ele_src_v, void *ele_dst_v,
         const char hflag_mask);
diff --git a/source/blender/bmesh/intern/bmesh_marking.c b/source/blender/bmesh/intern/bmesh_marking.c
index 7178a8132d2..7f2032d5f53 100644
--- a/source/blender/bmesh/intern/bmesh_marking.c
+++ b/source/blender/bmesh/intern/bmesh_marking.c
@@ -70,7 +70,7 @@ static void recount_totsels(BMesh *bm)
 	}
 }
 
-/** \name BMesh helper functions for selection flushing.
+/** \name BMesh helper functions for selection & hide flushing.
  * \{ */
 
 static bool bm_vert_is_edge_select_any_other(const BMVert *v, const BMEdge *e_first)
@@ -102,6 +102,20 @@ static bool bm_vert_is_edge_select_any(const BMVert *v)
 }
 #endif
 
+static bool bm_vert_is_edge_visible_any(const BMVert *v)
+{
+	if (v->e) {
+		const BMEdge *e_iter, *e_first;
+		e_iter = e_first = v->e;
+		do {
+			if (!BM_elem_flag_test(e_iter, BM_ELEM_HIDDEN)) {
+				return true;
+			}
+		} while ((e_iter = bmesh_disk_edge_next(e_iter, v)) != e_first);
+	}
+	return false;
+}
+
 static bool bm_edge_is_face_select_any_other(BMLoop *l_first)
 {
 	const BMLoop *l_iter = l_first;
@@ -131,6 +145,20 @@ static bool bm_edge_is_face_select_any(const BMEdge *e)
 }
 #endif
 
+static bool bm_edge_is_face_visible_any(const BMEdge *e)
+{
+	if (e->l) {
+		const BMLoop *l_iter, *l_first;
+		l_iter = l_first = e->l;
+		do {
+			if (!BM_elem_flag_test(l_iter->f, BM_ELEM_HIDDEN)) {
+				return true;
+			}
+		} while ((l_iter = l_iter->radial_next) != l_first);
+	}
+	return false;
+}
+
 /** \} */
 
 /**
@@ -1198,87 +1226,111 @@ void BM_mesh_elem_hflag_enable_all(
 
 /***************** Mesh Hiding stuff *********** */
 
+/**
+ * Hide unless any connected elements are visible.
+ * Run this after hiding a connected edge or face.
+ */
 static void vert_flush_hide_set(BMVert *v)
 {
-	BMIter iter;
-	BMEdge *e;
-	bool hide = true;
-
-	BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) {
-		hide = hide && BM_elem_flag_test(e, BM_ELEM_HIDDEN);
-	}
-
-	BM_elem_flag_set(v, BM_ELEM_HIDDEN, hide);
+	BM_elem_flag_set(v, BM_ELEM_HIDDEN, !bm_vert_is_edge_visible_any(v));
 }
 
-static void edge_flush_hide(BMEdge *e)
+/**
+ * Hide unless any connected elements are visible.
+ * Run this after hiding a connected face.
+ */
+static void edge_flush_hide_set(BMEdge *e)
 {
-	BMIter iter;
-	BMFace *f;
-	bool hide = true;
-
-	BM_ITER_ELEM (f, &iter, e, BM_FACES_OF_EDGE) {
-		hide = hide && BM_elem_flag_test(f, BM_ELEM_HIDDEN);
-	}
-
-	BM_elem_flag_set(e, BM_ELEM_HIDDEN, hide);
+	BM_elem_flag_set(e, BM_ELEM_HIDDEN, !bm_edge_is_face_visible_any(e));
 }
 
 void BM_vert_hide_set(BMVert *v, const bool hide)
 {
 	/* vert hiding: vert + surrounding edges and faces */
-	BMIter iter, fiter;
-	BMEdge *e;
-	BMFace *f;
-
 	BLI_assert(v->head.htype == BM_VERT);
+	if (hide) {
+		BLI_assert(!BM_elem_flag_test(v, BM_ELEM_SELECT));
+	}
 
 	BM_elem_flag_set(v, BM_ELEM_HIDDEN, hide);
 
-	BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) {
-		BM_elem_flag_set(e, BM_ELEM_HIDDEN, hide);
-
-		BM_ITER_ELEM (f, &fiter, e, BM_FACES_OF_EDGE) {
-			BM_elem_flag_set(f, BM_ELEM_HIDDEN, hide);
-		}
+	if (v->e) {
+		BMEdge *e_iter, *e_first;
+		e_iter = e_first = v->e;
+		do {
+			BM_elem_flag_set(e_iter, BM_ELEM_HIDDEN, hide);
+			if (e_iter->l) {
+				const BMLoop *l_radial_iter, *l_radial_first;
+				l_radial_iter = l_radial_first = e_iter->l;
+				do {
+					BM_elem_flag_set(l_radial_iter->f, BM_ELEM_HIDDEN, hide);
+				} while ((l_radial_iter = l_radial_iter->radial_next) != l_radial_first);
+			}
+		} while ((e_iter = bmesh_disk_edge_next(e_iter, v)) != e_first);
 	}
 }
 
 void BM_edge_hide_set(BMEdge *e, const bool hide)
 {
-	BMIter iter;
-	BMFace *f;
-	/* BMVert *v; */
-
 	BLI_assert(e->head.htype == BM_EDGE);
+	if (hide) {
+		BLI_assert(!BM_elem_flag_test(e, BM_ELEM_SELECT));
+	}
 
 	/* edge hiding: faces around the edge */
-	BM_ITER_ELEM (f, &iter, e, BM_FACES_OF_EDGE) {
-		BM_elem_flag_set(f, BM_ELEM_HIDDEN, hide);
+	if (e->l) {
+		const BMLoop *l_iter, *l_first;
+		l_iter = l_first = e->l;
+		do {
+			BM_elem_flag_set(l_iter->f, BM_ELEM_HIDDEN, hide);
+		} while ((l_iter = l_iter->radial_next) != l_first);
 	}
 	
 	BM_elem_flag_set(e, BM_ELEM_HIDDEN, hide);
 
 	/* hide vertices if necessary */
-	vert_flush_hide_set(e->v1);
-	vert_flush_hide_set(e->v2);
+	if (hide) {
+		vert_flush_hide_set(e->v1);
+		vert_flush_hide_set(e->v2);
+	}
+	else {
+		BM_elem_flag_disable(e->v1, BM_ELEM_HIDDEN);
+		BM_elem_flag_disable(e->v2, BM_ELEM_HIDDEN);
+	}
 }
 
 void BM_face_hide_set(BMFace *f, const bool hide)
 {
-	BMIter iter;
-	BMLoop *l;
-
 	BLI_assert(f->head.htype == BM_FACE);
+	if (hide) {
+		BLI_assert(!BM_elem_flag_test(f, BM_ELEM_SELECT));
+	}
 
 	BM_elem_flag_set(f, BM_ELEM_HIDDEN, hide);
 
-	BM_ITER_ELEM (l, &iter, f, BM_LOOPS_OF_FACE) {
-		edge_flush_hide(l->e);
+	if (hide) {
+		BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
+		BMLoop *l_iter;
+
+		l_iter = l_first;
+		do {
+			edge_flush_hide_set(l_iter->e);
+		} while ((l_iter = l_iter->next) != l_first);
+
+		l_iter = l_first;
+		do {
+			vert_flush_hide_set(l_iter->v);
+		} while ((l_iter = l_iter->next) != l_first);
 	}
+	else {
+		BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
+		BMLoop *l_iter;
 
-	BM_ITER_ELEM (l, &iter, f, BM_LOOPS_OF_FACE) {
-		vert_flush_hide_set(l->v);
+		l_iter = l_first;
+		do {
+			BM_elem_flag_disable(l_iter->e, BM_ELEM_HIDDEN);
+			BM_elem_flag_disable(l_iter->v, BM_ELEM_HIDDEN);
+		} while ((l_iter = l_iter->next) != l_first);
 	}
 }
 
diff --git a/source/blender/bmesh/operators/bmo_create.c b/source/blender/bmesh/operators/bmo_create.c
index 7b8cb36ab59..a980baf8626 100644
--- a/source/blender/bmesh/operators/bmo_create.c
+++ b/source/blender/bmesh/operators/bmo_create.c
@@ -290,7 +290,11 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
 		BMFace *f;
 
 		BMO_iter_as_array(op->slots_in, "geom", BM_VERT, (void **)vert_arr, totv);
-		f = BM_face_create_ngon_vcloud(bm, vert_arr, totv, NULL, BM_CREATE_NO_DOUBLE);
+
+		BM_verts_sort_radial_plane(vert_arr, totv);
+
+		/* create edges and find the winding (if faces are attached to any existing edges) */
+		f = BM_face_create_ngon_verts(bm, vert_arr, totv, NULL, BM_CREATE_NO_DOUBLE, true, true);
 
 		if (f) {
 			BMO_face_flag_enable(bm, f, ELE_OUT);
diff --git a/source/blender/bmesh/operators/bmo_inset.c b/source/blender/bmesh/operators/bmo_inset.c
index c52c608e671..e2ff09669d7 100644
--- a/source/blender/bmesh/operators/bmo_inset.c
+++ b/source/blender/bmesh/operators/bmo_inset.c
@@ -647,6 +647,10 @@ void bmo_inset_region_exec(BMesh *bm, BMOperator *op)
 	} (void)0
 #define VERT_ORIG_GET(_v)  \
 	(const float *)BLI_ghash_lookup_default(vert_coords, (_v), (_v)->co)
+	/* memory for the coords isn't given back to the arena,
+	 * acceptable in this case since it runs a fixed number of times. */
+#define VERT_ORIG_REMOVE(_v)  \
+	BLI_ghash_remove(vert_coords, (_v), NULL, NULL)
 
 
 	for (i = 0, es = edge_info; i < edge_info_len; i++, es++) {
@@ -972,7 +976,11 @@ void bmo_inset_region_exec(BMesh *bm, BMOperator *op)
 								v_glue = v_split;
 							}
 							else {
-								BM_vert_splice(bm, v_glue, v_split);
+								if (BM_vert_splice(bm, v_glue, v_split)) {
+									if (use_vert_coords_orig) {
+										VERT_ORIG_REMOVE(v_split);
+									}
+								}
 							}
 						}
 					}
diff --git a/source/blender/editors/gpencil/CMakeLists.txt b/source/blender/editors/gpencil/CMakeLists.txt
index 6604d595573..3d5317b2ebd 100644
--- a/source/blender/editors/gpencil/CMakeLists.txt
+++ b/source/blender/editors/gpencil/CMakeLists.txt
@@ -44,6 +44,7 @@ set(SRC
 	gpencil_convert.c
 	gpencil_data.c
 	gpencil_edit.c
+	gpencil_interpolate.c
 	gpencil_ops.c
 	gpencil_paint.c
 	gpencil_select.c
diff --git a/source/blender/editors/gpencil/drawgpencil.c b/source/blender/editors/gpencil/drawgpencil.c
index 8a4ba6687cd..e8a812817d1 100644
--- a/source/blender/editors/gpencil/drawgpencil.c
+++ b/source/blender/editors/gpencil/drawgpencil.c
@@ -1632,7 +1632,7 @@ static void gp_draw_data_all(Scene *scene, bGPdata *gpd, int offsx, int offsy, i
 {
 	bGPdata *gpd_source = NULL;
 	ToolSettings *ts;
-	bGPDbrush *brush;
+	bGPDbrush *brush = NULL;
 	if (scene) {
 		ts = scene->toolsettings;
 		brush = BKE_gpencil_brush_getactive(ts);
@@ -1641,8 +1641,7 @@ static void gp_draw_data_all(Scene *scene, bGPdata *gpd, int offsx, int offsy, i
 			BKE_gpencil_brush_init_presets(ts);
 			brush = BKE_gpencil_brush_getactive(ts);
 		}
-	}
-	if (scene) {
+
 		if (spacetype == SPACE_VIEW3D) {
 			gpd_source = (scene->gpd ? scene->gpd : NULL);
 		}
diff --git a/source/blender/editors/gpencil/gpencil_edit.c b/source/blender/editors/gpencil/gpencil_edit.c
index 15f65b394a9..5b011b679a6 100644
--- a/source/blender/editors/gpencil/gpencil_edit.c
+++ b/source/blender/editors/gpencil/gpencil_edit.c
@@ -682,6 +682,87 @@ void GPENCIL_OT_move_to_layer(wmOperatorType *ot)
 	RNA_def_enum_funcs(ot->prop, ED_gpencil_layers_with_new_enum_itemf);
 }
 
+/* ********************* Add Blank Frame *************************** */
+
+/* Basically the same as the drawing op */
+static int UNUSED_FUNCTION(gp_blank_frame_add_poll)(bContext *C)
+{
+	if (ED_operator_regionactive(C)) {
+		/* check if current context can support GPencil data */
+		if (ED_gpencil_data_get_pointers(C, NULL) != NULL) {
+			return 1;
+		}
+		else {
+			CTX_wm_operator_poll_msg_set(C, "Failed to find Grease Pencil data to draw into");
+		}
+	}
+	else {
+		CTX_wm_operator_poll_msg_set(C, "Active region not set");
+	}
+	
+	return 0;
+}
+
+static int gp_blank_frame_add_exec(bContext *C, wmOperator *op)
+{
+	Scene *scene = CTX_data_scene(C);
+	bGPdata *gpd = ED_gpencil_data_get_active(C);
+	bGPDlayer *active_gpl = BKE_gpencil_layer_getactive(gpd);
+
+	const bool all_layers = RNA_boolean_get(op->ptr, "all_layers");
+
+	/* Initialise datablock and an active layer if nothing exists yet */
+	if (ELEM(NULL, gpd, active_gpl)) {
+		/* let's just be lazy, and call the "Add New Layer" operator, which sets everything up as required */
+		WM_operator_name_call(C, "GPENCIL_OT_layer_add", WM_OP_EXEC_DEFAULT, NULL);
+	}
+	
+	/* Go through each layer, adding a frame after the active one 
+	 * and/or shunting all the others out of the way
+	 */
+	CTX_DATA_BEGIN(C, bGPDlayer *, gpl, editable_gpencil_layers)
+	{
+		if ((all_layers == false) && (gpl != active_gpl)) {
+			continue;
+		}
+
+		/* 1) Check for an existing frame on the current frame */
+		bGPDframe *gpf = BKE_gpencil_layer_find_frame(gpl, CFRA);
+		if (gpf) {
+			/* Shunt all frames after (and including) the existing one later by 1-frame */
+			for (; gpf; gpf = gpf->next) {
+				gpf->framenum += 1;
+			}
+		}
+		
+		/* 2) Now add a new frame, with nothing in it */
+		gpl->actframe = BKE_gpencil_layer_getframe(gpl, CFRA, GP_GETFRAME_ADD_NEW);
+	}
+	CTX_DATA_END;
+	
+	/* notifiers */
+	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
+	
+	return OPERATOR_FINISHED;
+}
+
+void GPENCIL_OT_blank_frame_add(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name = "Add Blank Frame";
+	ot->idname = "GPENCIL_OT_blank_frame_add";
+	ot->description = "Add a new frame with nothing in it on the current frame. "
+	                  "If there is already a frame, all existing frames are shifted one frame later";
+	
+	/* callbacks */
+	ot->exec = gp_blank_frame_add_exec;
+	ot->poll = gp_add_poll;
+	
+	/* properties */
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+	RNA_def_boolean(ot->srna, "all_layers", false, "All Layers", "Create blank frame in all layers, not only active");
+}
+
 /* ******************* Delete Active Frame ************************ */
 
 static int gp_actframe_delete_poll(bContext *C)
@@ -1897,6 +1978,13 @@ void GPENCIL_OT_stroke_flip(wmOperatorType *ot)
 
 /* ***************** Reproject Strokes ********************** */
 
+typedef enum eGP_ReprojectModes {
+	/* On same plane, parallel to viewplane */
+	GP_REPROJECT_PLANAR = 0,
+	/* Reprojected on to the scene geometry */
+	GP_REPROJECT_SURFACE,
+} eGP_ReprojectModes;
+
 static int gp_strokes_reproject_poll(bContext *C)
 {
 	/* 2 Requirements:
@@ -1906,14 +1994,23 @@ static int gp_strokes_reproject_poll(bContext *C)
 	return (gp_stroke_edit_poll(C) && ED_operator_view3d_active(C));
 }
 
-static int gp_strokes_reproject_exec(bContext *C, wmOperator *UNUSED(op))
+static int gp_strokes_reproject_exec(bContext *C, wmOperator *op)
 {
 	Scene *scene = CTX_data_scene(C);
 	GP_SpaceConversion gsc = {NULL};
+	eGP_ReprojectModes mode = RNA_boolean_get(op->ptr, "type");
 	
 	/* init space conversion stuff */
 	gp_point_conversion_init(C, &gsc);
 	
+	/* init autodist for geometry projection */
+	if (mode == GP_REPROJECT_SURFACE) {
+		view3d_region_operator_needs_opengl(CTX_wm_window(C), gsc.ar);
+		ED_view3d_autodist_init(scene, gsc.ar, CTX_wm_view3d(C), 0);
+	}
+	
+	// TODO: For deforming geometry workflow, create new frames?
+	
 	/* Go through each editable + selected stroke, adjusting each of its points one by one... */
 	GP_EDITABLE_STROKES_BEGIN(C, gpl, gps)
 	{
@@ -1949,7 +2046,27 @@ static int gp_strokes_reproject_exec(bContext *C, wmOperator *UNUSED(op))
 				/* Project screenspace back to 3D space (from current perspective)
 				 * so that all points have been treated the same way
 				 */
-				gp_point_xy_to_3d(&gsc, scene, xy, &pt->x);
+				if (mode == GP_REPROJECT_PLANAR) {
+					/* Planar - All on same plane parallel to the viewplane */
+					gp_point_xy_to_3d(&gsc, scene, xy, &pt->x);
+				}
+				else {
+					/* Geometry - Snap to surfaces of visible geometry */
+					/* XXX: There will be precision loss (possible stairstep artifacts) from this conversion to satisfy the API's */
+					const int screen_co[2] = {(int)xy[0], (int)xy[1]};
+					
+					int depth_margin = 0; // XXX: 4 for strokes, 0 for normal
+					float depth;
+					
+					/* XXX: The proper procedure computes the depths into an array, to have smooth transitions when all else fails... */
+					if (ED_view3d_autodist_depth(gsc.ar, screen_co, depth_margin, &depth)) {
+						ED_view3d_autodist_simple(gsc.ar, screen_co, &pt->x, 0, &depth);
+					}
+					else {
+						/* Default to planar */
+						gp_point_xy_to_3d(&gsc, scene, xy, &pt->x);
+					}
+				}
 				
 				/* Unapply parent corrections */
 				if (gpl->parent) {
@@ -1966,21 +2083,36 @@ static int gp_strokes_reproject_exec(bContext *C, wmOperator *UNUSED(op))
 
 void GPENCIL_OT_reproject(wmOperatorType *ot)
 {
+	static EnumPropertyItem reproject_type[] = {
+		{GP_REPROJECT_PLANAR, "PLANAR", 0, "Planar", 
+		 "Reproject the strokes to end up on the same plane, as if drawn from the current viewpoint "
+		 "using 'Cursor' Stroke Placement"},
+		{GP_REPROJECT_SURFACE, "SURFACE", 0, "Surface",
+		 "Reproject the strokes on to the scene geometry, as if drawn using 'Surface' placement"},
+		{0, NULL, 0, NULL, NULL}
+	};
+	
 	/* identifiers */
 	ot->name = "Reproject Strokes";
 	ot->idname = "GPENCIL_OT_reproject";
-	ot->description = "Reproject the selected strokes from the current viewpoint to get all points on the same plane again "
-	                  "(e.g. to fix problems from accidental 3D cursor movement, or viewport changes)";
+	ot->description = "Reproject the selected strokes from the current viewpoint as if they had been newly drawn "
+	                  "(e.g. to fix problems from accidental 3D cursor movement or accidental viewport changes, "
+	                  "or for matching deforming geometry)";
 	
 	/* callbacks */
+	ot->invoke = WM_menu_invoke;
 	ot->exec = gp_strokes_reproject_exec;
 	ot->poll = gp_strokes_reproject_poll;
 	
 	/* flags */
 	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+	
+	/* properties */
+	ot->prop = RNA_def_enum(ot->srna, "type", reproject_type, GP_REPROJECT_PLANAR, "Projection Type", "");
 }
 
 /* ******************* Stroke subdivide ************************** */
+
 /* helper: Count how many points need to be inserted */
 static int gp_count_subdivision_cuts(bGPDstroke *gps)
 {
@@ -2098,673 +2230,3 @@ void GPENCIL_OT_stroke_subdivide(wmOperatorType *ot)
 	RNA_def_property_flag(prop, PROP_SKIP_SAVE);
 
 }
-
-/* =========  Interpolation operators ========================== */
-/* Helper: Update point with interpolation */
-static void gp_interpolate_update_points(bGPDstroke *gps_from, bGPDstroke *gps_to, bGPDstroke *new_stroke, float factor)
-{
-	bGPDspoint *prev, *pt, *next;
-
-	/* update points */
-	for (int i = 0; i < new_stroke->totpoints; i++) {
-		prev = &gps_from->points[i];
-		pt = &new_stroke->points[i];
-		next = &gps_to->points[i];
-
-		/* Interpolate all values */
-		interp_v3_v3v3(&pt->x, &prev->x, &next->x, factor);
-		pt->pressure = interpf(prev->pressure, next->pressure, factor);
-		pt->strength = interpf(prev->strength, next->strength, factor);
-		CLAMP(pt->strength, GPENCIL_STRENGTH_MIN, 1.0f);
-	}
-}
-
-/* Helper: Update all strokes interpolated */
-static void gp_interpolate_update_strokes(bContext *C, tGPDinterpolate *tgpi)
-{
-	tGPDinterpolate_layer *tgpil;
-	bGPDstroke *new_stroke, *gps_from, *gps_to;
-	int cStroke;
-	float factor;
-	float shift = tgpi->shift;
-
-	for (tgpil = tgpi->ilayers.first; tgpil; tgpil = tgpil->next) {
-		factor = tgpil->factor + shift;
-		for (new_stroke = tgpil->interFrame->strokes.first; new_stroke; new_stroke = new_stroke->next) {
-			if (new_stroke->totpoints == 0) {
-				continue;
-			}
-			/* get strokes to interpolate */
-			cStroke = BLI_findindex(&tgpil->interFrame->strokes, new_stroke);
-			gps_from = BLI_findlink(&tgpil->prevFrame->strokes, cStroke);
-			gps_to = BLI_findlink(&tgpil->nextFrame->strokes, cStroke);
-			/* update points position */
-			if ((gps_from) && (gps_to)) {
-				gp_interpolate_update_points(gps_from, gps_to, new_stroke, factor);
-			}
-		}
-	}
-
-	WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL);
-}
-
-/* Helper: Verify valid strokes for interpolation */
-static bool gp_interpolate_check_todo(bContext *C, bGPdata *gpd)
-{
-	ToolSettings *ts = CTX_data_tool_settings(C);
-	int flag = ts->gp_sculpt.flag;
-
-	bGPDlayer *gpl;
-	bGPDlayer *active_gpl = CTX_data_active_gpencil_layer(C);
-	bGPDstroke *gps_from, *gps_to;
-	int fFrame;
-
-	/* get layers */
-	for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
-		/* all layers or only active */
-		if (((flag & GP_BRUSHEDIT_FLAG_INTERPOLATE_ALL_LAYERS) == 0) && (gpl != active_gpl)) {
-			continue;
-		}
-		/* only editable and visible layers are considered */
-		if (!gpencil_layer_is_editable(gpl) || (gpl->actframe == NULL)) {
-			continue;
-		}
-		/* read strokes */
-		for (gps_from = gpl->actframe->strokes.first; gps_from; gps_from = gps_from->next) {
-			/* only selected */
-			if ((flag & GP_BRUSHEDIT_FLAG_INTERPOLATE_ONLY_SELECTED) && ((gps_from->flag & GP_STROKE_SELECT) == 0)) {
-				continue;
-			}
-			/* skip strokes that are invalid for current view */
-			if (ED_gpencil_stroke_can_use(C, gps_from) == false) {
-				continue;
-			}
-			/* check if the color is editable */
-			if (ED_gpencil_stroke_color_use(gpl, gps_from) == false) {
-				continue;
-			}
-			/* get final stroke to interpolate */
-			fFrame = BLI_findindex(&gpl->actframe->strokes, gps_from);
-			gps_to = BLI_findlink(&gpl->actframe->next->strokes, fFrame);
-			if (gps_to == NULL) {
-				continue;
-			}
-			return 1;
-		}
-	}
-	return 0;
-}
-
-/* Helper: Create internal strokes interpolated */
-static void gp_interpolate_set_points(bContext *C, tGPDinterpolate *tgpi)
-{
-	bGPDlayer *gpl;
-	bGPdata *gpd = tgpi->gpd;
-	tGPDinterpolate_layer *tgpil;
-	bGPDlayer *active_gpl = CTX_data_active_gpencil_layer(C);
-	bGPDstroke *gps_from, *gps_to, *new_stroke;
-	int fFrame;
-
-	/* save initial factor for active layer to define shift limits */
-	tgpi->init_factor = (float)(tgpi->cframe - active_gpl->actframe->framenum) / (active_gpl->actframe->next->framenum - active_gpl->actframe->framenum + 1);
-	/* limits are 100% below 0 and 100% over the 100% */
-	tgpi->low_limit = -1.0f - tgpi->init_factor;
-	tgpi->high_limit = 2.0f - tgpi->init_factor;
-
-	/* set layers */
-	for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
-		/* all layers or only active */
-		if (((tgpi->flag & GP_BRUSHEDIT_FLAG_INTERPOLATE_ALL_LAYERS) == 0) && (gpl != active_gpl)) {
-			continue;
-		}
-		/* only editable and visible layers are considered */
-		if (!gpencil_layer_is_editable(gpl) || (gpl->actframe == NULL)) {
-			continue;
-		}
-		/* create temp data for each layer */
-		tgpil = NULL;
-		tgpil = MEM_callocN(sizeof(tGPDinterpolate_layer), "GPencil Interpolate Layer");
-
-		tgpil->gpl = gpl;
-		tgpil->prevFrame = gpl->actframe;
-		tgpil->nextFrame = gpl->actframe->next;
-
-		BLI_addtail(&tgpi->ilayers, tgpil);
-		/* create a new temporary frame */
-		tgpil->interFrame = MEM_callocN(sizeof(bGPDframe), "bGPDframe");
-		tgpil->interFrame->framenum = tgpi->cframe;
-
-		/* get interpolation factor by layer (usually must be equal for all layers, but not sure) */
-		tgpil->factor = (float)(tgpi->cframe - tgpil->prevFrame->framenum) / (tgpil->nextFrame->framenum - tgpil->prevFrame->framenum + 1);
-		/* create new strokes data with interpolated points reading original stroke */
-		for (gps_from = tgpil->prevFrame->strokes.first; gps_from; gps_from = gps_from->next) {
-			bool valid = true;
-			/* only selected */
-			if ((tgpi->flag & GP_BRUSHEDIT_FLAG_INTERPOLATE_ONLY_SELECTED) && ((gps_from->flag & GP_STROKE_SELECT) == 0)) {
-				valid = false;
-			}
-
-			/* skip strokes that are invalid for current view */
-			if (ED_gpencil_stroke_can_use(C, gps_from) == false) {
-				valid = false;
-			}
-			/* check if the color is editable */
-			if (ED_gpencil_stroke_color_use(tgpil->gpl, gps_from) == false) {
-				valid = false;
-			}
-			/* get final stroke to interpolate */
-			fFrame = BLI_findindex(&tgpil->prevFrame->strokes, gps_from);
-			gps_to = BLI_findlink(&tgpil->nextFrame->strokes, fFrame);
-			if (gps_to == NULL) {
-				valid = false;
-			}
-			/* create new stroke */
-			new_stroke = MEM_dupallocN(gps_from);
-			new_stroke->points = MEM_dupallocN(gps_from->points);
-			new_stroke->triangles = MEM_dupallocN(gps_from->triangles);
-			if (valid) {
-				/* if destination stroke is smaller, resize new_stroke to size of gps_to stroke */
-				if (gps_from->totpoints > gps_to->totpoints) {
-					new_stroke->points = MEM_recallocN(new_stroke->points, sizeof(*new_stroke->points) * gps_to->totpoints);
-					new_stroke->totpoints = gps_to->totpoints;
-					new_stroke->tot_triangles = 0;
-					new_stroke->flag |= GP_STROKE_RECALC_CACHES;
-				}
-				/* update points position */
-				gp_interpolate_update_points(gps_from, gps_to, new_stroke, tgpil->factor);
-			}
-			else {
-				/* need an empty stroke to keep index correct for lookup, but resize to smallest size */
-				new_stroke->totpoints = 0;
-				new_stroke->points = MEM_recallocN(new_stroke->points, sizeof(*new_stroke->points));
-				new_stroke->tot_triangles = 0;
-				new_stroke->triangles = MEM_recallocN(new_stroke->triangles, sizeof(*new_stroke->triangles));
-			}
-			/* add to strokes */
-			BLI_addtail(&tgpil->interFrame->strokes, new_stroke);
-		}
-	}
-}
-
-/* Helper: calculate shift based on position of mouse (we only use x-axis for now.
-* since this is more convenient for users to do), and store new shift value
-*/
-static void gpencil_mouse_update_shift(tGPDinterpolate *tgpi, wmOperator *op, const wmEvent *event)
-{
-	float mid = (float)(tgpi->ar->winx - tgpi->ar->winrct.xmin) / 2.0f;
-	float mpos = event->x - tgpi->ar->winrct.xmin;
-	if (mpos >= mid) {
-		tgpi->shift = ((mpos - mid) * tgpi->high_limit) / mid;
-	}
-	else {
-		tgpi->shift = tgpi->low_limit - ((mpos * tgpi->low_limit) / mid);
-	}
-
-	CLAMP(tgpi->shift, tgpi->low_limit, tgpi->high_limit);
-	RNA_float_set(op->ptr, "shift", tgpi->shift);
-}
-
-/* Helper: Draw status message while the user is running the operator */
-static void gpencil_interpolate_status_indicators(tGPDinterpolate *p)
-{
-	Scene *scene = p->scene;
-	char status_str[UI_MAX_DRAW_STR];
-	char msg_str[UI_MAX_DRAW_STR];
-	BLI_strncpy(msg_str, IFACE_("GPencil Interpolation: ESC/RMB to cancel, Enter/LMB to confirm, WHEEL/MOVE to adjust, Factor"), UI_MAX_DRAW_STR);
-
-	if (hasNumInput(&p->num)) {
-		char str_offs[NUM_STR_REP_LEN];
-
-		outputNumInput(&p->num, str_offs, &scene->unit);
-
-		BLI_snprintf(status_str, sizeof(status_str), "%s: %s", msg_str, str_offs);
-	}
-	else {
-		BLI_snprintf(status_str, sizeof(status_str), "%s: %d %%", msg_str, (int)((p->init_factor + p->shift)  * 100.0f));
-	}
-
-	ED_area_headerprint(p->sa, status_str);
-}
-
-/* Helper: Update screen and stroke */
-static void gpencil_interpolate_update(bContext *C, wmOperator *op, tGPDinterpolate *tgpi)
-{
-	/* update shift indicator in header */
-	gpencil_interpolate_status_indicators(tgpi);
-	/* apply... */
-	tgpi->shift = RNA_float_get(op->ptr, "shift");
-	/* update points position */
-	gp_interpolate_update_strokes(C, tgpi);
-}
-
-/* init new temporary interpolation data */
-static bool gp_interpolate_set_init_values(bContext *C, wmOperator *op, tGPDinterpolate *tgpi)
-{
-	ToolSettings *ts = CTX_data_tool_settings(C);
-	bGPdata *gpd = CTX_data_gpencil_data(C);
-
-	/* set current scene and window */
-	tgpi->scene = CTX_data_scene(C);
-	tgpi->sa = CTX_wm_area(C);
-	tgpi->ar = CTX_wm_region(C);
-	tgpi->flag = ts->gp_sculpt.flag;
-
-	/* set current frame number */
-	tgpi->cframe = tgpi->scene->r.cfra;
-
-	/* set GP datablock */
-	tgpi->gpd = gpd;
-
-	/* set interpolation weight */
-	tgpi->shift = RNA_float_get(op->ptr, "shift");
-	/* set layers */
-	gp_interpolate_set_points(C, tgpi);
-
-	return 1;
-}
-
-/* Poll handler: check if context is suitable for interpolation */
-static int gpencil_interpolate_poll(bContext *C)
-{
-	bGPdata * gpd = CTX_data_gpencil_data(C);
-	bGPDlayer *gpl = CTX_data_active_gpencil_layer(C);
-	/* only 3D view */
-	if (CTX_wm_area(C)->spacetype != SPACE_VIEW3D) {
-		return 0;
-	}
-	/* need data to interpolate */
-	if (ELEM(NULL, gpd, gpl)) {
-		return 0;
-	}
-
-	return 1;
-}
-
-/* Allocate memory and initialize values */
-static tGPDinterpolate *gp_session_init_interpolation(bContext *C, wmOperator *op)
-{
-	tGPDinterpolate *tgpi = NULL;
-
-	/* create new context data */
-	tgpi = MEM_callocN(sizeof(tGPDinterpolate), "GPencil Interpolate Data");
-
-	/* define initial values */
-	gp_interpolate_set_init_values(C, op, tgpi);
-
-	/* return context data for running operator */
-	return tgpi;
-}
-
-/* Exit and free memory */
-static void gpencil_interpolate_exit(bContext *C, wmOperator *op)
-{
-	tGPDinterpolate *tgpi = op->customdata;
-	tGPDinterpolate_layer *tgpil;
-
-	/* don't assume that operator data exists at all */
-	if (tgpi) {
-		/* remove drawing handler */
-		if (tgpi->draw_handle_screen) {
-			ED_region_draw_cb_exit(tgpi->ar->type, tgpi->draw_handle_screen);
-		}
-		if (tgpi->draw_handle_3d) {
-			ED_region_draw_cb_exit(tgpi->ar->type, tgpi->draw_handle_3d);
-		}
-		/* clear status message area */
-		ED_area_headerprint(tgpi->sa, NULL);
-		/* finally, free memory used by temp data */
-		for (tgpil = tgpi->ilayers.first; tgpil; tgpil = tgpil->next) {
-			BKE_gpencil_free_strokes(tgpil->interFrame);
-			MEM_freeN(tgpil->interFrame);
-		}
-
-		BLI_freelistN(&tgpi->ilayers);
-		MEM_freeN(tgpi);
-	}
-	WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL);
-
-	/* clear pointer */
-	op->customdata = NULL;
-}
-
-/* Cancel handler */
-static void gpencil_interpolate_cancel(bContext *C, wmOperator *op)
-{
-	/* this is just a wrapper around exit() */
-	gpencil_interpolate_exit(C, op);
-}
-
-/* Init interpolation: Allocate memory and set init values         */
-static int gpencil_interpolate_init(bContext *C, wmOperator *op)
-{
-	tGPDinterpolate *tgpi;
-	/* check context */
-	tgpi = op->customdata = gp_session_init_interpolation(C, op);
-	if (tgpi == NULL) {
-		/* something wasn't set correctly in context */
-		gpencil_interpolate_exit(C, op);
-		return 0;
-	}
-
-	/* everything is now setup ok */
-	return 1;
-}
-
-/* ********************** custom drawcall api ***************** */
-/* Helper: drawing callback for modal operator in screen mode */
-static void gpencil_interpolate_draw_screen(const struct bContext *UNUSED(C), ARegion *UNUSED(ar), void *arg)
-{
-	wmOperator *op = arg;
-	struct tGPDinterpolate *tgpi = op->customdata;
-	ED_gp_draw_interpolation(tgpi, REGION_DRAW_POST_PIXEL);
-}
-
-/* Helper: drawing callback for modal operator in 3d mode */
-static void gpencil_interpolate_draw_3d(const struct bContext *UNUSED(C), ARegion *UNUSED(ar), void *arg)
-{
-	wmOperator *op = arg;
-	struct tGPDinterpolate *tgpi = op->customdata;
-	ED_gp_draw_interpolation(tgpi, REGION_DRAW_POST_VIEW);
-}
-
-/* Invoke handler: Initialize the operator */
-static int gpencil_interpolate_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
-{
-	wmWindow *win = CTX_wm_window(C);
-	Scene *scene = CTX_data_scene(C);
-	bGPdata * gpd = CTX_data_gpencil_data(C);
-	bGPDlayer *gpl = CTX_data_active_gpencil_layer(C);
-	tGPDinterpolate *tgpi = NULL;
-
-	/* cannot interpolate if not between 2 frames */
-	if ((gpl->actframe == NULL) || (gpl->actframe->next == NULL)) {
-		BKE_report(op->reports, RPT_ERROR, "Interpolation requires to be between two grease pencil frames in active layer");
-		return OPERATOR_CANCELLED;
-	}
-
-	/* cannot interpolate in extremes */
-	if ((gpl->actframe->framenum == scene->r.cfra) || (gpl->actframe->next->framenum == scene->r.cfra)) {
-		BKE_report(op->reports, RPT_ERROR, "Interpolation requires to be between two grease pencil frames in active layer");
-		return OPERATOR_CANCELLED;
-	}
-
-	/* need editable strokes */
-	if (!gp_interpolate_check_todo(C, gpd)) {
-		BKE_report(op->reports, RPT_ERROR, "Interpolation requires some editable stroke");
-		return OPERATOR_CANCELLED;
-	}
-
-	/* try to initialize context data needed */
-	if (!gpencil_interpolate_init(C, op)) {
-		if (op->customdata)
-			MEM_freeN(op->customdata);
-		return OPERATOR_CANCELLED;
-	}
-	else
-		tgpi = op->customdata;
-
-	/* enable custom drawing handlers. It needs 2 handlers because can be strokes in 3d space and screen space and each handler use different
-	   coord system */
-	tgpi->draw_handle_screen = ED_region_draw_cb_activate(tgpi->ar->type, gpencil_interpolate_draw_screen, op, REGION_DRAW_POST_PIXEL);
-	tgpi->draw_handle_3d = ED_region_draw_cb_activate(tgpi->ar->type, gpencil_interpolate_draw_3d, op, REGION_DRAW_POST_VIEW);
-	/* set cursor to indicate modal */
-	WM_cursor_modal_set(win, BC_EW_SCROLLCURSOR);
-	/* update shift indicator in header */
-	gpencil_interpolate_status_indicators(tgpi);
-	WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL);
-
-	/* add a modal handler for this operator */
-	WM_event_add_modal_handler(C, op);
-
-	return OPERATOR_RUNNING_MODAL;
-}
-
-/* Modal handler: Events handling during interactive part */
-static int gpencil_interpolate_modal(bContext *C, wmOperator *op, const wmEvent *event)
-{
-	tGPDinterpolate *tgpi = op->customdata;
-	wmWindow *win = CTX_wm_window(C);
-	bGPDframe *gpf_dst;
-	bGPDstroke *gps_src, *gps_dst;
-	tGPDinterpolate_layer *tgpil;
-	const bool has_numinput = hasNumInput(&tgpi->num);
-
-	switch (event->type) {
-		case LEFTMOUSE: /* confirm */
-		case RETKEY:
-		{
-			/* return to normal cursor and header status */
-			ED_area_headerprint(tgpi->sa, NULL);
-			WM_cursor_modal_restore(win);
-
-			/* insert keyframes as required... */
-			for (tgpil = tgpi->ilayers.first; tgpil; tgpil = tgpil->next) {
-				gpf_dst = BKE_gpencil_layer_getframe(tgpil->gpl, tgpi->cframe, GP_GETFRAME_ADD_NEW);
-				gpf_dst->key_type = BEZT_KEYTYPE_BREAKDOWN;
-				
-				/* copy strokes */
-				BLI_listbase_clear(&gpf_dst->strokes);
-				for (gps_src = tgpil->interFrame->strokes.first; gps_src; gps_src = gps_src->next) {
-					if (gps_src->totpoints == 0) {
-						continue;
-					}
-					/* make copy of source stroke, then adjust pointer to points too */
-					gps_dst = MEM_dupallocN(gps_src);
-					gps_dst->points = MEM_dupallocN(gps_src->points);
-					gps_dst->triangles = MEM_dupallocN(gps_src->triangles);
-					gps_dst->flag |= GP_STROKE_RECALC_CACHES;
-					BLI_addtail(&gpf_dst->strokes, gps_dst);
-				}
-			}
-			/* clean up temp data */
-			gpencil_interpolate_exit(C, op);
-
-			/* done! */
-			return OPERATOR_FINISHED;
-		}
-
-		case ESCKEY:    /* cancel */
-		case RIGHTMOUSE:
-		{
-			/* return to normal cursor and header status */
-			ED_area_headerprint(tgpi->sa, NULL);
-			WM_cursor_modal_restore(win);
-
-			/* clean up temp data */
-			gpencil_interpolate_exit(C, op);
-
-			/* canceled! */
-			return OPERATOR_CANCELLED;
-		}
-		case WHEELUPMOUSE:
-		{
-			tgpi->shift = tgpi->shift + 0.01f;
-			CLAMP(tgpi->shift, tgpi->low_limit, tgpi->high_limit);
-			RNA_float_set(op->ptr, "shift", tgpi->shift);
-			/* update screen */
-			gpencil_interpolate_update(C, op, tgpi);
-			break;
-		}
-		case WHEELDOWNMOUSE:
-		{
-			tgpi->shift = tgpi->shift - 0.01f;
-			CLAMP(tgpi->shift, tgpi->low_limit, tgpi->high_limit);
-			RNA_float_set(op->ptr, "shift", tgpi->shift);
-			/* update screen */
-			gpencil_interpolate_update(C, op, tgpi);
-			break;
-		}
-		case MOUSEMOVE: /* calculate new position */
-		{
-			/* only handle mousemove if not doing numinput */
-			if (has_numinput == false) {
-				/* update shift based on position of mouse */
-				gpencil_mouse_update_shift(tgpi, op, event);
-				/* update screen */
-				gpencil_interpolate_update(C, op, tgpi);
-			}
-			break;
-		}
-		default:
-			if ((event->val == KM_PRESS) && handleNumInput(C, &tgpi->num, event)) {
-				float value;
-				float factor = tgpi->init_factor;
-
-				/* Grab shift from numeric input, and store this new value (the user see an int) */
-				value = (factor + tgpi->shift) * 100.0f;
-				applyNumInput(&tgpi->num, &value);
-				tgpi->shift = value / 100.0f;
-				/* recalculate the shift to get the right value in the frame scale */
-				tgpi->shift = tgpi->shift - factor;
-
-				CLAMP(tgpi->shift, tgpi->low_limit, tgpi->high_limit);
-				RNA_float_set(op->ptr, "shift", tgpi->shift);
-
-				/* update screen */
-				gpencil_interpolate_update(C, op, tgpi);
-
-				break;
-			}
-			else {
-				/* unhandled event - allow to pass through */
-				return OPERATOR_RUNNING_MODAL | OPERATOR_PASS_THROUGH;
-			}
-	}
-
-	/* still running... */
-	return OPERATOR_RUNNING_MODAL;
-}
-
-/* Define modal operator for interpolation */
-void GPENCIL_OT_interpolate(wmOperatorType *ot)
-{
-	/* identifiers */
-	ot->name = "Grease Pencil Interpolation";
-	ot->idname = "GPENCIL_OT_interpolate";
-	ot->description = "Interpolate grease pencil strokes between frames";
-
-	/* api callbacks */
-	ot->invoke = gpencil_interpolate_invoke;
-	ot->modal = gpencil_interpolate_modal;
-	ot->cancel = gpencil_interpolate_cancel;
-	ot->poll = gpencil_interpolate_poll;
-
-	/* flags */
-	ot->flag = OPTYPE_UNDO | OPTYPE_BLOCKING;
-
-	RNA_def_float_percentage(ot->srna, "shift", 0.0f, -1.0f, 1.0f, "Shift", "Displacement factor for the interpolate operation", -0.9f, 0.9f);
-}
-
-/* =============== Interpolate sequence ===============*/
-/* Create Sequence Interpolation */
-static int gpencil_interpolate_seq_exec(bContext *C, wmOperator *op)
-{
-	Scene *scene = CTX_data_scene(C);
-	ToolSettings *ts = CTX_data_tool_settings(C);
-	bGPdata * gpd = CTX_data_gpencil_data(C);
-	bGPDlayer *active_gpl = CTX_data_active_gpencil_layer(C);
-	bGPDlayer *gpl;
-	bGPDframe *prevFrame, *nextFrame, *interFrame;
-	bGPDstroke *gps_from, *gps_to, *new_stroke;
-	float factor;
-	int cframe, fFrame;
-	int flag = ts->gp_sculpt.flag;
-
-	/* cannot interpolate if not between 2 frames */
-	if ((active_gpl->actframe == NULL) || (active_gpl->actframe->next == NULL)) {
-		BKE_report(op->reports, RPT_ERROR, "Interpolation requires to be between two grease pencil frames");
-		return OPERATOR_CANCELLED;
-	}
-	/* cannot interpolate in extremes */
-	if ((active_gpl->actframe->framenum == scene->r.cfra) || (active_gpl->actframe->next->framenum == scene->r.cfra)) {
-		BKE_report(op->reports, RPT_ERROR, "Interpolation requires to be between two grease pencil frames");
-		return OPERATOR_CANCELLED;
-	}
-	
-	/* loop all layer to check if need interpolation */
-	for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
-		/* all layers or only active */
-		if (((flag & GP_BRUSHEDIT_FLAG_INTERPOLATE_ALL_LAYERS) == 0) && (gpl != active_gpl)) {
-			continue;
-		}
-		/* only editable and visible layers are considered */
-		if (!gpencil_layer_is_editable(gpl) || (gpl->actframe == NULL)) {
-			continue;
-		}
-		/* store extremes */
-		prevFrame = gpl->actframe;
-		nextFrame = gpl->actframe->next;
-		/* Loop over intermediary frames and create the interpolation */
-		for (cframe = prevFrame->framenum + 1; cframe < nextFrame->framenum; cframe++) {
-			interFrame = NULL;
-
-			/* get interpolation factor */
-			factor = (float)(cframe - prevFrame->framenum) / (nextFrame->framenum - prevFrame->framenum + 1);
-
-			/* create new strokes data with interpolated points reading original stroke */
-			for (gps_from = prevFrame->strokes.first; gps_from; gps_from = gps_from->next) {
-				/* only selected */
-				if ((flag & GP_BRUSHEDIT_FLAG_INTERPOLATE_ONLY_SELECTED) && ((gps_from->flag & GP_STROKE_SELECT) == 0)) {
-					continue;
-				}
-				/* skip strokes that are invalid for current view */
-				if (ED_gpencil_stroke_can_use(C, gps_from) == false) {
-					continue;
-				}
-				/* check if the color is editable */
-				if (ED_gpencil_stroke_color_use(gpl, gps_from) == false) {
-					continue;
-				}
-				/* get final stroke to interpolate */
-				fFrame = BLI_findindex(&prevFrame->strokes, gps_from);
-				gps_to = BLI_findlink(&nextFrame->strokes, fFrame);
-				if (gps_to == NULL) {
-					continue;
-				}
-				/* create a new frame if needed */
-				if (interFrame == NULL) {
-					interFrame = BKE_gpencil_layer_getframe(gpl, cframe, GP_GETFRAME_ADD_NEW);
-					interFrame->key_type = BEZT_KEYTYPE_BREAKDOWN;
-				}
-				/* create new stroke */
-				new_stroke = MEM_dupallocN(gps_from);
-				new_stroke->points = MEM_dupallocN(gps_from->points);
-				new_stroke->triangles = MEM_dupallocN(gps_from->triangles);
-				/* if destination stroke is smaller, resize new_stroke to size of gps_to stroke */
-				if (gps_from->totpoints > gps_to->totpoints) {
-					new_stroke->points = MEM_recallocN(new_stroke->points, sizeof(*new_stroke->points) * gps_to->totpoints);
-					new_stroke->totpoints = gps_to->totpoints;
-					new_stroke->tot_triangles = 0;
-					new_stroke->flag |= GP_STROKE_RECALC_CACHES;
-				}
-				/* update points position */
-				gp_interpolate_update_points(gps_from, gps_to, new_stroke, factor);
-
-				/* add to strokes */
-				BLI_addtail(&interFrame->strokes, new_stroke);
-			}
-		}
-	}
-
-	/* notifiers */
-	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
-
-	return OPERATOR_FINISHED;
-}
-
-/* Define sequence interpolation               */
-void GPENCIL_OT_interpolate_sequence(wmOperatorType *ot)
-{
-	/* identifiers */
-	ot->name = "Grease Pencil Sequence Interpolation";
-	ot->idname = "GPENCIL_OT_interpolate_sequence";
-	ot->description = "Interpolate full grease pencil strokes sequence between frames";
-
-	/* api callbacks */
-	ot->exec = gpencil_interpolate_seq_exec;
-	ot->poll = gpencil_interpolate_poll;
-
-	/* flags */
-	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-}
-/* =========  End Interpolation operators ========================== */
diff --git a/source/blender/editors/gpencil/gpencil_intern.h b/source/blender/editors/gpencil/gpencil_intern.h
index e2e5fc28710..5c7c9b84adb 100644
--- a/source/blender/editors/gpencil/gpencil_intern.h
+++ b/source/blender/editors/gpencil/gpencil_intern.h
@@ -287,6 +287,8 @@ void GPENCIL_OT_unlock_all(struct wmOperatorType *ot);
 void GPENCIL_OT_layer_isolate(struct wmOperatorType *ot);
 void GPENCIL_OT_layer_merge(struct wmOperatorType *ot);
 
+void GPENCIL_OT_blank_frame_add(struct wmOperatorType *ot);
+
 void GPENCIL_OT_active_frame_delete(struct wmOperatorType *ot);
 void GPENCIL_OT_active_frames_delete_all(struct wmOperatorType *ot);
 
@@ -340,6 +342,7 @@ void gpencil_undo_finish(void);
 
 void GPENCIL_OT_interpolate(struct wmOperatorType *ot);
 void GPENCIL_OT_interpolate_sequence(struct wmOperatorType *ot);
+void GPENCIL_OT_interpolate_reverse(struct wmOperatorType *ot);
 
 /* ****************************************************** */
 /* FILTERED ACTION DATA - TYPES  ---> XXX DEPRECEATED OLD ANIM SYSTEM CODE! */
diff --git a/source/blender/editors/gpencil/gpencil_interpolate.c b/source/blender/editors/gpencil/gpencil_interpolate.c
new file mode 100644
index 00000000000..297058168a0
--- /dev/null
+++ b/source/blender/editors/gpencil/gpencil_interpolate.c
@@ -0,0 +1,1145 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2016, Blender Foundation
+ * This is a new part of Blender
+ *
+ * Contributor(s): Antonio Vazquez, Joshua Leung
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ *
+ * Operators for interpolating new Grease Pencil frames from existing strokes
+ */
+
+/** \file blender/editors/gpencil/gpencil_interpolate.c
+ *  \ingroup edgpencil
+ */
+
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <math.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_blenlib.h"
+#include "BLI_utildefines.h"
+#include "BLI_easing.h"
+#include "BLI_math.h"
+
+#include "BLT_translation.h"
+
+#include "DNA_color_types.h"
+#include "DNA_gpencil_types.h"
+#include "DNA_object_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_screen_types.h"
+#include "DNA_space_types.h"
+#include "DNA_view3d_types.h"
+
+#include "BKE_colortools.h"
+#include "BKE_context.h"
+#include "BKE_global.h"
+#include "BKE_gpencil.h"
+#include "BKE_library.h"
+#include "BKE_report.h"
+#include "BKE_screen.h"
+
+#include "UI_interface.h"
+#include "UI_resources.h"
+
+#include "WM_api.h"
+#include "WM_types.h"
+
+#include "RNA_access.h"
+#include "RNA_define.h"
+#include "RNA_enum_types.h"
+
+#include "UI_view2d.h"
+
+#include "ED_gpencil.h"
+#include "ED_object.h"
+#include "ED_screen.h"
+#include "ED_view3d.h"
+#include "ED_screen.h"
+#include "ED_space_api.h"
+
+#include "gpencil_intern.h"
+
+/* ************************************************ */
+/* Core/Shared Utilities */
+
+/* Poll callback for interpolation operators */
+static int gpencil_interpolate_poll(bContext *C)
+{
+	bGPdata *gpd = CTX_data_gpencil_data(C);
+	bGPDlayer *gpl = CTX_data_active_gpencil_layer(C);
+	
+	/* only 3D view */
+	if (CTX_wm_area(C)->spacetype != SPACE_VIEW3D) {
+		return 0;
+	}
+	
+	/* need data to interpolate */
+	if (ELEM(NULL, gpd, gpl)) {
+		return 0;
+	}
+	
+	return 1;
+}
+
+/* Perform interpolation */
+static void gp_interpolate_update_points(bGPDstroke *gps_from, bGPDstroke *gps_to, bGPDstroke *new_stroke, float factor)
+{
+	bGPDspoint *prev, *pt, *next;
+	
+	/* update points */
+	for (int i = 0; i < new_stroke->totpoints; i++) {
+		prev = &gps_from->points[i];
+		pt = &new_stroke->points[i];
+		next = &gps_to->points[i];
+		
+		/* Interpolate all values */
+		interp_v3_v3v3(&pt->x, &prev->x, &next->x, factor);
+		pt->pressure = interpf(prev->pressure, next->pressure, factor);
+		pt->strength = interpf(prev->strength, next->strength, factor);
+		CLAMP(pt->strength, GPENCIL_STRENGTH_MIN, 1.0f);
+	}
+}
+
+/* ****************** Interpolate Interactive *********************** */
+
+/* Helper: Update all strokes interpolated */
+static void gp_interpolate_update_strokes(bContext *C, tGPDinterpolate *tgpi)
+{
+	tGPDinterpolate_layer *tgpil;
+	const float shift = tgpi->shift;
+	
+	for (tgpil = tgpi->ilayers.first; tgpil; tgpil = tgpil->next) {
+		bGPDstroke *new_stroke;
+		const float factor = tgpil->factor + shift;
+		
+		for (new_stroke = tgpil->interFrame->strokes.first; new_stroke; new_stroke = new_stroke->next) {
+			bGPDstroke *gps_from, *gps_to;
+			int stroke_idx;
+			
+			if (new_stroke->totpoints == 0) {
+				continue;
+			}
+			
+			/* get strokes to interpolate */
+			stroke_idx = BLI_findindex(&tgpil->interFrame->strokes, new_stroke);
+			
+			gps_from = BLI_findlink(&tgpil->prevFrame->strokes, stroke_idx);
+			gps_to = BLI_findlink(&tgpil->nextFrame->strokes, stroke_idx);
+			
+			/* update points position */
+			if ((gps_from) && (gps_to)) {
+				gp_interpolate_update_points(gps_from, gps_to, new_stroke, factor);
+			}
+		}
+	}
+	
+	WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL);
+}
+
+/* Helper: Verify valid strokes for interpolation */
+static bool gp_interpolate_check_todo(bContext *C, bGPdata *gpd)
+{
+	ToolSettings *ts = CTX_data_tool_settings(C);
+	eGP_Interpolate_SettingsFlag flag = ts->gp_interpolate.flag;
+	
+	/* get layers */
+	for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
+		/* all layers or only active */
+		if (!(flag & GP_TOOLFLAG_INTERPOLATE_ALL_LAYERS) && !(gpl->flag & GP_LAYER_ACTIVE)) {
+			continue;
+		}
+		/* only editable and visible layers are considered */
+		if (!gpencil_layer_is_editable(gpl) || (gpl->actframe == NULL)) {
+			continue;
+		}
+		
+		/* read strokes */
+		for (bGPDstroke *gps_from = gpl->actframe->strokes.first; gps_from; gps_from = gps_from->next) {
+			bGPDstroke *gps_to;
+			int fFrame;
+			
+			/* only selected */
+			if ((flag & GP_TOOLFLAG_INTERPOLATE_ONLY_SELECTED) && ((gps_from->flag & GP_STROKE_SELECT) == 0)) {
+				continue;
+			}
+			/* skip strokes that are invalid for current view */
+			if (ED_gpencil_stroke_can_use(C, gps_from) == false) {
+				continue;
+			}
+			/* check if the color is editable */
+			if (ED_gpencil_stroke_color_use(gpl, gps_from) == false) {
+				continue;
+			}
+			
+			/* get final stroke to interpolate */
+			fFrame = BLI_findindex(&gpl->actframe->strokes, gps_from);
+			gps_to = BLI_findlink(&gpl->actframe->next->strokes, fFrame);
+			if (gps_to == NULL) {
+				continue;
+			}
+			
+			return true;
+		}
+	}
+	return false;
+}
+
+/* Helper: Create internal strokes interpolated */
+static void gp_interpolate_set_points(bContext *C, tGPDinterpolate *tgpi)
+{
+	bGPdata *gpd = tgpi->gpd;
+	bGPDlayer *active_gpl = CTX_data_active_gpencil_layer(C);
+	bGPDframe *actframe = active_gpl->actframe;
+	
+	/* save initial factor for active layer to define shift limits */
+	tgpi->init_factor = (float)(tgpi->cframe - actframe->framenum) / (actframe->next->framenum - actframe->framenum + 1);
+	
+	/* limits are 100% below 0 and 100% over the 100% */
+	tgpi->low_limit = -1.0f - tgpi->init_factor;
+	tgpi->high_limit = 2.0f - tgpi->init_factor;
+	
+	/* set layers */
+	for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
+		tGPDinterpolate_layer *tgpil;
+		
+		/* all layers or only active */
+		if (!(tgpi->flag & GP_TOOLFLAG_INTERPOLATE_ALL_LAYERS) && (gpl != active_gpl)) {
+			continue;
+		}
+		/* only editable and visible layers are considered */
+		if (!gpencil_layer_is_editable(gpl) || (gpl->actframe == NULL)) {
+			continue;
+		}
+		
+		/* create temp data for each layer */
+		tgpil = MEM_callocN(sizeof(tGPDinterpolate_layer), "GPencil Interpolate Layer");
+		
+		tgpil->gpl = gpl;
+		tgpil->prevFrame = gpl->actframe;
+		tgpil->nextFrame = gpl->actframe->next;
+		
+		BLI_addtail(&tgpi->ilayers, tgpil);
+		
+		/* create a new temporary frame */
+		tgpil->interFrame = MEM_callocN(sizeof(bGPDframe), "bGPDframe");
+		tgpil->interFrame->framenum = tgpi->cframe;
+		
+		/* get interpolation factor by layer (usually must be equal for all layers, but not sure) */
+		tgpil->factor = (float)(tgpi->cframe - tgpil->prevFrame->framenum) / (tgpil->nextFrame->framenum - tgpil->prevFrame->framenum + 1);
+		
+		/* create new strokes data with interpolated points reading original stroke */
+		for (bGPDstroke *gps_from = tgpil->prevFrame->strokes.first; gps_from; gps_from = gps_from->next) {
+			bGPDstroke *gps_to;
+			int fFrame;
+			
+			bGPDstroke *new_stroke;
+			bool valid = true;
+			
+			
+			/* only selected */
+			if ((tgpi->flag & GP_TOOLFLAG_INTERPOLATE_ONLY_SELECTED) && ((gps_from->flag & GP_STROKE_SELECT) == 0)) {
+				valid = false;
+			}
+			/* skip strokes that are invalid for current view */
+			if (ED_gpencil_stroke_can_use(C, gps_from) == false) {
+				valid = false;
+			}
+			
+			/* check if the color is editable */
+			if (ED_gpencil_stroke_color_use(tgpil->gpl, gps_from) == false) {
+				valid = false;
+			}
+			
+			/* get final stroke to interpolate */
+			fFrame = BLI_findindex(&tgpil->prevFrame->strokes, gps_from);
+			gps_to = BLI_findlink(&tgpil->nextFrame->strokes, fFrame);
+			if (gps_to == NULL) {
+				valid = false;
+			}
+			
+			/* create new stroke */
+			new_stroke = MEM_dupallocN(gps_from);
+			new_stroke->points = MEM_dupallocN(gps_from->points);
+			new_stroke->triangles = MEM_dupallocN(gps_from->triangles);
+			
+			if (valid) {
+				/* if destination stroke is smaller, resize new_stroke to size of gps_to stroke */
+				if (gps_from->totpoints > gps_to->totpoints) {
+					new_stroke->points = MEM_recallocN(new_stroke->points, sizeof(*new_stroke->points) * gps_to->totpoints);
+					new_stroke->totpoints = gps_to->totpoints;
+					new_stroke->tot_triangles = 0;
+					new_stroke->flag |= GP_STROKE_RECALC_CACHES;
+				}
+				/* update points position */
+				gp_interpolate_update_points(gps_from, gps_to, new_stroke, tgpil->factor);
+			}
+			else {
+				/* need an empty stroke to keep index correct for lookup, but resize to smallest size */
+				new_stroke->totpoints = 0;
+				new_stroke->points = MEM_recallocN(new_stroke->points, sizeof(*new_stroke->points));
+				new_stroke->tot_triangles = 0;
+				new_stroke->triangles = MEM_recallocN(new_stroke->triangles, sizeof(*new_stroke->triangles));
+			}
+			
+			/* add to strokes */
+			BLI_addtail(&tgpil->interFrame->strokes, new_stroke);
+		}
+	}
+}
+
+/* ----------------------- */
+/* Drawing Callbacks */
+
+/* Drawing callback for modal operator in screen mode */
+static void gpencil_interpolate_draw_screen(const struct bContext *UNUSED(C), ARegion *UNUSED(ar), void *arg)
+{
+	tGPDinterpolate *tgpi = (tGPDinterpolate *)arg;
+	ED_gp_draw_interpolation(tgpi, REGION_DRAW_POST_PIXEL);
+}
+
+/* Drawing callback for modal operator in 3d mode */
+static void gpencil_interpolate_draw_3d(const bContext *UNUSED(C), ARegion *UNUSED(ar), void *arg)
+{
+	tGPDinterpolate *tgpi = (tGPDinterpolate *)arg;
+	ED_gp_draw_interpolation(tgpi, REGION_DRAW_POST_VIEW);
+}
+
+/* ----------------------- */
+
+/* Helper: calculate shift based on position of mouse (we only use x-axis for now.
+ * since this is more convenient for users to do), and store new shift value
+ */
+static void gpencil_mouse_update_shift(tGPDinterpolate *tgpi, wmOperator *op, const wmEvent *event)
+{
+	float mid = (float)(tgpi->ar->winx - tgpi->ar->winrct.xmin) / 2.0f;
+	float mpos = event->x - tgpi->ar->winrct.xmin;
+	
+	if (mpos >= mid) {
+		tgpi->shift = ((mpos - mid) * tgpi->high_limit) / mid;
+	}
+	else {
+		tgpi->shift = tgpi->low_limit - ((mpos * tgpi->low_limit) / mid);
+	}
+	
+	CLAMP(tgpi->shift, tgpi->low_limit, tgpi->high_limit);
+	RNA_float_set(op->ptr, "shift", tgpi->shift);
+}
+
+/* Helper: Draw status message while the user is running the operator */
+static void gpencil_interpolate_status_indicators(tGPDinterpolate *p)
+{
+	Scene *scene = p->scene;
+	char status_str[UI_MAX_DRAW_STR];
+	char msg_str[UI_MAX_DRAW_STR];
+	
+	BLI_strncpy(msg_str, IFACE_("GPencil Interpolation: ESC/RMB to cancel, Enter/LMB to confirm, WHEEL/MOVE to adjust factor"), UI_MAX_DRAW_STR);
+	
+	if (hasNumInput(&p->num)) {
+		char str_offs[NUM_STR_REP_LEN];
+		
+		outputNumInput(&p->num, str_offs, &scene->unit);
+		BLI_snprintf(status_str, sizeof(status_str), "%s: %s", msg_str, str_offs);
+	}
+	else {
+		BLI_snprintf(status_str, sizeof(status_str), "%s: %d %%", msg_str, (int)((p->init_factor + p->shift)  * 100.0f));
+	}
+	
+	ED_area_headerprint(p->sa, status_str);
+}
+
+/* Update screen and stroke */
+static void gpencil_interpolate_update(bContext *C, wmOperator *op, tGPDinterpolate *tgpi)
+{
+	/* update shift indicator in header */
+	gpencil_interpolate_status_indicators(tgpi);
+	/* apply... */
+	tgpi->shift = RNA_float_get(op->ptr, "shift");
+	/* update points position */
+	gp_interpolate_update_strokes(C, tgpi);
+}
+
+/* ----------------------- */
+
+/* Exit and free memory */
+static void gpencil_interpolate_exit(bContext *C, wmOperator *op)
+{
+	tGPDinterpolate *tgpi = op->customdata;
+	tGPDinterpolate_layer *tgpil;
+	
+	/* don't assume that operator data exists at all */
+	if (tgpi) {
+		/* remove drawing handler */
+		if (tgpi->draw_handle_screen) {
+			ED_region_draw_cb_exit(tgpi->ar->type, tgpi->draw_handle_screen);
+		}
+		if (tgpi->draw_handle_3d) {
+			ED_region_draw_cb_exit(tgpi->ar->type, tgpi->draw_handle_3d);
+		}
+		
+		/* clear status message area */
+		ED_area_headerprint(tgpi->sa, NULL);
+		
+		/* finally, free memory used by temp data */
+		for (tgpil = tgpi->ilayers.first; tgpil; tgpil = tgpil->next) {
+			BKE_gpencil_free_strokes(tgpil->interFrame);
+			MEM_freeN(tgpil->interFrame);
+		}
+		
+		BLI_freelistN(&tgpi->ilayers);
+		MEM_freeN(tgpi);
+	}
+	WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL);
+	
+	/* clear pointer */
+	op->customdata = NULL;
+}
+
+/* Init new temporary interpolation data */
+static bool gp_interpolate_set_init_values(bContext *C, wmOperator *op, tGPDinterpolate *tgpi)
+{
+	ToolSettings *ts = CTX_data_tool_settings(C);
+	bGPdata *gpd = CTX_data_gpencil_data(C);
+	
+	/* set current scene and window */
+	tgpi->scene = CTX_data_scene(C);
+	tgpi->sa = CTX_wm_area(C);
+	tgpi->ar = CTX_wm_region(C);
+	tgpi->flag = ts->gp_interpolate.flag;
+	
+	/* set current frame number */
+	tgpi->cframe = tgpi->scene->r.cfra;
+	
+	/* set GP datablock */
+	tgpi->gpd = gpd;
+	
+	/* set interpolation weight */
+	tgpi->shift = RNA_float_get(op->ptr, "shift");
+	/* set layers */
+	gp_interpolate_set_points(C, tgpi);
+	
+	return 1;
+}
+
+/* Allocate memory and initialize values */
+static tGPDinterpolate *gp_session_init_interpolation(bContext *C, wmOperator *op)
+{
+	tGPDinterpolate *tgpi = MEM_callocN(sizeof(tGPDinterpolate), "GPencil Interpolate Data");
+	
+	/* define initial values */
+	gp_interpolate_set_init_values(C, op, tgpi);
+	
+	/* return context data for running operator */
+	return tgpi;
+}
+
+/* Init interpolation: Allocate memory and set init values */
+static int gpencil_interpolate_init(bContext *C, wmOperator *op)
+{
+	tGPDinterpolate *tgpi;
+	
+	/* check context */
+	tgpi = op->customdata = gp_session_init_interpolation(C, op);
+	if (tgpi == NULL) {
+		/* something wasn't set correctly in context */
+		gpencil_interpolate_exit(C, op);
+		return 0;
+	}
+	
+	/* everything is now setup ok */
+	return 1;
+}
+
+/* ----------------------- */
+
+/* Invoke handler: Initialize the operator */
+static int gpencil_interpolate_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
+{
+	wmWindow *win = CTX_wm_window(C);
+	Scene *scene = CTX_data_scene(C);
+	bGPdata *gpd = CTX_data_gpencil_data(C);
+	bGPDlayer *gpl = CTX_data_active_gpencil_layer(C);
+	bGPDframe *actframe = gpl->actframe;
+	tGPDinterpolate *tgpi = NULL;
+
+	/* cannot interpolate if not between 2 frames */
+	if (ELEM(NULL, actframe, actframe->next)) {
+		BKE_report(op->reports, RPT_ERROR, "Cannot find a pair of grease pencil frames to interpolate between in active layer");
+		return OPERATOR_CANCELLED;
+	}
+	
+	/* cannot interpolate in extremes */
+	if (ELEM(CFRA, actframe->framenum, actframe->next->framenum)) {
+		BKE_report(op->reports, RPT_ERROR, "Cannot interpolate as current frame already has existing grease pencil frames");
+		return OPERATOR_CANCELLED;
+	}
+	
+	/* need editable strokes */
+	if (!gp_interpolate_check_todo(C, gpd)) {
+		BKE_report(op->reports, RPT_ERROR, "Interpolation requires some editable strokes");
+		return OPERATOR_CANCELLED;
+	}
+	
+	/* try to initialize context data needed */
+	if (!gpencil_interpolate_init(C, op)) {
+		if (op->customdata)
+			MEM_freeN(op->customdata);
+		return OPERATOR_CANCELLED;
+	}
+	else {
+		tgpi = op->customdata;
+	}
+	
+	/* Enable custom drawing handlers
+	 * It needs 2 handlers because strokes can in 3d space and screen space 
+	 * and each handler use different coord system 
+	 */
+	tgpi->draw_handle_screen = ED_region_draw_cb_activate(tgpi->ar->type, gpencil_interpolate_draw_screen, tgpi, REGION_DRAW_POST_PIXEL);
+	tgpi->draw_handle_3d = ED_region_draw_cb_activate(tgpi->ar->type, gpencil_interpolate_draw_3d, tgpi, REGION_DRAW_POST_VIEW);
+	
+	/* set cursor to indicate modal */
+	WM_cursor_modal_set(win, BC_EW_SCROLLCURSOR);
+	
+	/* update shift indicator in header */
+	gpencil_interpolate_status_indicators(tgpi);
+	WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL);
+	
+	/* add a modal handler for this operator */
+	WM_event_add_modal_handler(C, op);
+	
+	return OPERATOR_RUNNING_MODAL;
+}
+
+/* Modal handler: Events handling during interactive part */
+static int gpencil_interpolate_modal(bContext *C, wmOperator *op, const wmEvent *event)
+{
+	tGPDinterpolate *tgpi = op->customdata;
+	wmWindow *win = CTX_wm_window(C);
+	bGPDframe *gpf_dst;
+	bGPDstroke *gps_src, *gps_dst;
+	tGPDinterpolate_layer *tgpil;
+	const bool has_numinput = hasNumInput(&tgpi->num);
+	
+	switch (event->type) {
+		case LEFTMOUSE: /* confirm */
+		case RETKEY:
+		{
+			/* return to normal cursor and header status */
+			ED_area_headerprint(tgpi->sa, NULL);
+			WM_cursor_modal_restore(win);
+			
+			/* insert keyframes as required... */
+			for (tgpil = tgpi->ilayers.first; tgpil; tgpil = tgpil->next) {
+				gpf_dst = BKE_gpencil_layer_getframe(tgpil->gpl, tgpi->cframe, GP_GETFRAME_ADD_NEW);
+				gpf_dst->key_type = BEZT_KEYTYPE_BREAKDOWN;
+				
+				/* copy strokes */
+				BLI_listbase_clear(&gpf_dst->strokes);
+				for (gps_src = tgpil->interFrame->strokes.first; gps_src; gps_src = gps_src->next) {
+					if (gps_src->totpoints == 0) {
+						continue;
+					}
+					
+					/* make copy of source stroke, then adjust pointer to points too */
+					gps_dst = MEM_dupallocN(gps_src);
+					gps_dst->points = MEM_dupallocN(gps_src->points);
+					gps_dst->triangles = MEM_dupallocN(gps_src->triangles);
+					gps_dst->flag |= GP_STROKE_RECALC_CACHES;
+					BLI_addtail(&gpf_dst->strokes, gps_dst);
+				}
+			}
+			
+			/* clean up temp data */
+			gpencil_interpolate_exit(C, op);
+			
+			/* done! */
+			return OPERATOR_FINISHED;
+		}
+		
+		case ESCKEY:    /* cancel */
+		case RIGHTMOUSE:
+		{
+			/* return to normal cursor and header status */
+			ED_area_headerprint(tgpi->sa, NULL);
+			WM_cursor_modal_restore(win);
+			
+			/* clean up temp data */
+			gpencil_interpolate_exit(C, op);
+			
+			/* canceled! */
+			return OPERATOR_CANCELLED;
+		}
+		
+		case WHEELUPMOUSE:
+		{
+			tgpi->shift = tgpi->shift + 0.01f;
+			CLAMP(tgpi->shift, tgpi->low_limit, tgpi->high_limit);
+			RNA_float_set(op->ptr, "shift", tgpi->shift);
+			
+			/* update screen */
+			gpencil_interpolate_update(C, op, tgpi);
+			break;
+		}
+		case WHEELDOWNMOUSE:
+		{
+			tgpi->shift = tgpi->shift - 0.01f;
+			CLAMP(tgpi->shift, tgpi->low_limit, tgpi->high_limit);
+			RNA_float_set(op->ptr, "shift", tgpi->shift);
+			
+			/* update screen */
+			gpencil_interpolate_update(C, op, tgpi);
+			break;
+		}
+		case MOUSEMOVE: /* calculate new position */
+		{
+			/* only handle mousemove if not doing numinput */
+			if (has_numinput == false) {
+				/* update shift based on position of mouse */
+				gpencil_mouse_update_shift(tgpi, op, event);
+				
+				/* update screen */
+				gpencil_interpolate_update(C, op, tgpi);
+			}
+			break;
+		}
+		default:
+			if ((event->val == KM_PRESS) && handleNumInput(C, &tgpi->num, event)) {
+				const float factor = tgpi->init_factor;
+				float value;
+				
+				/* Grab shift from numeric input, and store this new value (the user see an int) */
+				value = (factor + tgpi->shift) * 100.0f;
+				applyNumInput(&tgpi->num, &value);
+				tgpi->shift = value / 100.0f;
+				
+				/* recalculate the shift to get the right value in the frame scale */
+				tgpi->shift = tgpi->shift - factor;
+				
+				CLAMP(tgpi->shift, tgpi->low_limit, tgpi->high_limit);
+				RNA_float_set(op->ptr, "shift", tgpi->shift);
+				
+				/* update screen */
+				gpencil_interpolate_update(C, op, tgpi);
+				
+				break;
+			}
+			else {
+				/* unhandled event - allow to pass through */
+				return OPERATOR_RUNNING_MODAL | OPERATOR_PASS_THROUGH;
+			}
+	}
+	
+	/* still running... */
+	return OPERATOR_RUNNING_MODAL;
+}
+
+/* Cancel handler */
+static void gpencil_interpolate_cancel(bContext *C, wmOperator *op)
+{
+	/* this is just a wrapper around exit() */
+	gpencil_interpolate_exit(C, op);
+}
+
+void GPENCIL_OT_interpolate(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name = "Grease Pencil Interpolation";
+	ot->idname = "GPENCIL_OT_interpolate";
+	ot->description = "Interpolate grease pencil strokes between frames";
+	
+	/* callbacks */
+	ot->invoke = gpencil_interpolate_invoke;
+	ot->modal = gpencil_interpolate_modal;
+	ot->cancel = gpencil_interpolate_cancel;
+	ot->poll = gpencil_interpolate_poll;
+	
+	/* flags */
+	ot->flag = OPTYPE_UNDO | OPTYPE_BLOCKING;
+	
+	/* properties */
+	RNA_def_float_percentage(ot->srna, "shift", 0.0f, -1.0f, 1.0f, "Shift", "Bias factor for which frame has more influence on the interpolated strokes", -0.9f, 0.9f);
+}
+
+/* ****************** Interpolate Sequence *********************** */
+
+/* Helper: Perform easing equation calculations for GP interpolation operator */
+static float gp_interpolate_seq_easing_calc(GP_Interpolate_Settings *ipo_settings, float time)
+{
+	const float begin  = 0.0f;
+	const float change = 1.0f;
+	const float duration = 1.0f;
+	
+	const float back = ipo_settings->back;
+	const float amplitude = ipo_settings->amplitude;
+	const float period = ipo_settings->period;
+	
+	eBezTriple_Easing easing = ipo_settings->easing;
+	float result = time;
+	
+	switch (ipo_settings->type) {
+		case GP_IPO_BACK:
+			switch (easing) {
+				case BEZT_IPO_EASE_IN:
+					result = BLI_easing_back_ease_in(time, begin, change, duration, back);
+					break;
+				case BEZT_IPO_EASE_OUT:
+					result = BLI_easing_back_ease_out(time, begin, change, duration, back);
+					break;
+				case BEZT_IPO_EASE_IN_OUT:
+					result = BLI_easing_back_ease_in_out(time, begin, change, duration, back);
+					break;
+					
+				default: /* default/auto: same as ease out */
+					result = BLI_easing_back_ease_out(time, begin, change, duration, back);
+					break;
+			}
+			break;
+
+		case GP_IPO_BOUNCE:
+			switch (easing) {
+				case BEZT_IPO_EASE_IN:
+					result = BLI_easing_bounce_ease_in(time, begin, change, duration);
+					break;
+				case BEZT_IPO_EASE_OUT:
+					result = BLI_easing_bounce_ease_out(time, begin, change, duration);
+					break;
+				case BEZT_IPO_EASE_IN_OUT:
+					result = BLI_easing_bounce_ease_in_out(time, begin, change, duration);
+					break;
+					
+				default: /* default/auto: same as ease out */
+					result = BLI_easing_bounce_ease_out(time, begin, change, duration);
+					break;
+			}
+			break;
+			
+		case GP_IPO_CIRC:
+			switch (easing) {
+				case BEZT_IPO_EASE_IN:
+					result = BLI_easing_circ_ease_in(time, begin, change, duration);
+					break;
+				case BEZT_IPO_EASE_OUT:
+					result = BLI_easing_circ_ease_out(time, begin, change, duration);
+					break;
+				case BEZT_IPO_EASE_IN_OUT:
+					result = BLI_easing_circ_ease_in_out(time, begin, change, duration);
+					break;
+					
+				default: /* default/auto: same as ease in */
+					result = BLI_easing_circ_ease_in(time, begin, change, duration);
+					break;
+			}
+			break;
+
+		case GP_IPO_CUBIC:
+			switch (easing) {
+				case BEZT_IPO_EASE_IN:
+					result = BLI_easing_cubic_ease_in(time, begin, change, duration);
+					break;
+				case BEZT_IPO_EASE_OUT:
+					result = BLI_easing_cubic_ease_out(time, begin, change, duration);
+					break;
+				case BEZT_IPO_EASE_IN_OUT:
+					result = BLI_easing_cubic_ease_in_out(time, begin, change, duration);
+					break;
+					
+				default: /* default/auto: same as ease in */
+					result = BLI_easing_cubic_ease_in(time, begin, change, duration);
+					break;
+			}
+			break;
+		
+		case GP_IPO_ELASTIC:
+			switch (easing) {
+				case BEZT_IPO_EASE_IN:
+					result = BLI_easing_elastic_ease_in(time, begin, change, duration, amplitude, period);
+					break;
+				case BEZT_IPO_EASE_OUT:
+					result = BLI_easing_elastic_ease_out(time, begin, change, duration, amplitude, period);
+					break;
+				case BEZT_IPO_EASE_IN_OUT:
+					result = BLI_easing_elastic_ease_in_out(time, begin, change, duration, amplitude, period);
+					break;
+					
+				default: /* default/auto: same as ease out */
+					result = BLI_easing_elastic_ease_out(time, begin, change, duration, amplitude, period);
+					break;
+			}
+			break;
+		
+		case GP_IPO_EXPO:
+			switch (easing) {
+				case BEZT_IPO_EASE_IN:
+					result = BLI_easing_expo_ease_in(time, begin, change, duration);
+					break;
+				case BEZT_IPO_EASE_OUT:
+					result = BLI_easing_expo_ease_out(time, begin, change, duration);
+					break;
+				case BEZT_IPO_EASE_IN_OUT:
+					result = BLI_easing_expo_ease_in_out(time, begin, change, duration);
+					break;
+					
+				default: /* default/auto: same as ease in */
+					result = BLI_easing_expo_ease_in(time, begin, change, duration);
+					break;
+			}
+			break;
+		
+		case GP_IPO_QUAD:
+			switch (easing) {
+				case BEZT_IPO_EASE_IN:
+					result = BLI_easing_quad_ease_in(time, begin, change, duration);
+					break;
+				case BEZT_IPO_EASE_OUT:
+					result = BLI_easing_quad_ease_out(time, begin, change, duration);
+					break;
+				case BEZT_IPO_EASE_IN_OUT:
+					result = BLI_easing_quad_ease_in_out(time, begin, change, duration);
+					break;
+				
+				default: /* default/auto: same as ease in */
+					result = BLI_easing_quad_ease_in(time, begin, change, duration);
+					break;
+			}
+			break;
+		
+		case GP_IPO_QUART:
+			switch (easing) {
+				case BEZT_IPO_EASE_IN:
+					result = BLI_easing_quart_ease_in(time, begin, change, duration);
+					break;
+				case BEZT_IPO_EASE_OUT:
+					result = BLI_easing_quart_ease_out(time, begin, change, duration);
+					break;
+				case BEZT_IPO_EASE_IN_OUT:
+					result = BLI_easing_quart_ease_in_out(time, begin, change, duration);
+					break;
+					
+				default: /* default/auto: same as ease in */
+					result = BLI_easing_quart_ease_in(time, begin, change, duration);
+					break;
+			}
+			break;
+		
+		case GP_IPO_QUINT:
+			switch (easing) {
+				case BEZT_IPO_EASE_IN:
+					result = BLI_easing_quint_ease_in(time, begin, change, duration);
+					break;
+				case BEZT_IPO_EASE_OUT:
+					result = BLI_easing_quint_ease_out(time, begin, change, duration);
+					break;
+				case BEZT_IPO_EASE_IN_OUT:
+					result = BLI_easing_quint_ease_in_out(time, begin, change, duration);
+					break;
+					
+				default: /* default/auto: same as ease in */
+					result = BLI_easing_quint_ease_in(time, begin, change, duration);
+					break;
+			}
+			break;
+		
+		case GP_IPO_SINE:
+			switch (easing) {
+				case BEZT_IPO_EASE_IN:
+					result = BLI_easing_sine_ease_in(time, begin, change, duration);
+					break;
+				case BEZT_IPO_EASE_OUT:
+					result = BLI_easing_sine_ease_out(time, begin, change, duration);
+					break;
+				case BEZT_IPO_EASE_IN_OUT:
+					result = BLI_easing_sine_ease_in_out(time, begin, change, duration);
+					break;
+					
+				default: /* default/auto: same as ease in */
+					result = BLI_easing_sine_ease_in(time, begin, change, duration);
+					break;
+			}
+			break;
+		
+		default:
+			printf("%s: Unknown interpolation type - %d\n", __func__, ipo_settings->type);
+			break;
+	}
+	
+	return result;
+}
+
+static int gpencil_interpolate_seq_exec(bContext *C, wmOperator *op)
+{
+	bGPdata   *gpd = CTX_data_gpencil_data(C);
+	bGPDlayer *active_gpl = CTX_data_active_gpencil_layer(C);
+	bGPDframe *actframe = active_gpl->actframe;
+	
+	Scene *scene = CTX_data_scene(C);
+	ToolSettings *ts = CTX_data_tool_settings(C);
+	GP_Interpolate_Settings *ipo_settings = &ts->gp_interpolate;
+	eGP_Interpolate_SettingsFlag flag = ipo_settings->flag;
+	
+	/* cannot interpolate if not between 2 frames */
+	if (ELEM(NULL, actframe, actframe->next)) {
+		BKE_report(op->reports, RPT_ERROR, "Cannot find a pair of grease pencil frames to interpolate between in active layer");
+		return OPERATOR_CANCELLED;
+	}
+	/* cannot interpolate in extremes */
+	if (ELEM(CFRA, actframe->framenum, actframe->next->framenum)) {
+		BKE_report(op->reports, RPT_ERROR, "Cannot interpolate as current frame already has existing grease pencil frames");
+		return OPERATOR_CANCELLED;
+	}
+	
+	/* loop all layer to check if need interpolation */
+	for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
+		bGPDframe *prevFrame, *nextFrame;
+		bGPDstroke *gps_from, *gps_to;
+		int cframe, fFrame;
+		
+		/* all layers or only active */
+		if (((flag & GP_TOOLFLAG_INTERPOLATE_ALL_LAYERS) == 0) && (gpl != active_gpl)) {
+			continue;
+		}
+		/* only editable and visible layers are considered */
+		if (!gpencil_layer_is_editable(gpl) || (gpl->actframe == NULL)) {
+			continue;
+		}
+		
+		/* store extremes */
+		prevFrame = gpl->actframe;
+		nextFrame = gpl->actframe->next;
+		
+		/* Loop over intermediary frames and create the interpolation */
+		for (cframe = prevFrame->framenum + 1; cframe < nextFrame->framenum; cframe++) {
+			bGPDframe *interFrame = NULL;
+			float factor;
+			
+			/* get interpolation factor */
+			factor = (float)(cframe - prevFrame->framenum) / (nextFrame->framenum - prevFrame->framenum + 1);
+			
+			if (ipo_settings->type == GP_IPO_CURVEMAP) {
+				/* custom curvemap */
+				if (ipo_settings->custom_ipo) {
+					factor = curvemapping_evaluateF(ipo_settings->custom_ipo, 0, factor);
+				}
+				else {
+					BKE_report(op->reports, RPT_ERROR, "Custom interpolation curve does not exist");
+				}
+			}
+			else if (ipo_settings->type >= GP_IPO_BACK) {
+				/* easing equation... */
+				factor = gp_interpolate_seq_easing_calc(ipo_settings, factor);
+			}
+			
+			/* create new strokes data with interpolated points reading original stroke */
+			for (gps_from = prevFrame->strokes.first; gps_from; gps_from = gps_from->next) {
+				bGPDstroke *new_stroke;
+				
+				/* only selected */
+				if ((flag & GP_TOOLFLAG_INTERPOLATE_ONLY_SELECTED) && ((gps_from->flag & GP_STROKE_SELECT) == 0)) {
+					continue;
+				}
+				/* skip strokes that are invalid for current view */
+				if (ED_gpencil_stroke_can_use(C, gps_from) == false) {
+					continue;
+				}
+				/* check if the color is editable */
+				if (ED_gpencil_stroke_color_use(gpl, gps_from) == false) {
+					continue;
+				}
+				
+				/* get final stroke to interpolate */
+				fFrame = BLI_findindex(&prevFrame->strokes, gps_from);
+				gps_to = BLI_findlink(&nextFrame->strokes, fFrame);
+				if (gps_to == NULL) {
+					continue;
+				}
+				
+				/* create a new frame if needed */
+				if (interFrame == NULL) {
+					interFrame = BKE_gpencil_layer_getframe(gpl, cframe, GP_GETFRAME_ADD_NEW);
+					interFrame->key_type = BEZT_KEYTYPE_BREAKDOWN;
+				}
+				
+				/* create new stroke */
+				new_stroke = MEM_dupallocN(gps_from);
+				new_stroke->points = MEM_dupallocN(gps_from->points);
+				new_stroke->triangles = MEM_dupallocN(gps_from->triangles);
+				
+				/* if destination stroke is smaller, resize new_stroke to size of gps_to stroke */
+				if (gps_from->totpoints > gps_to->totpoints) {
+					new_stroke->points = MEM_recallocN(new_stroke->points, sizeof(*new_stroke->points) * gps_to->totpoints);
+					new_stroke->totpoints = gps_to->totpoints;
+					new_stroke->tot_triangles = 0;
+					new_stroke->flag |= GP_STROKE_RECALC_CACHES;
+				}
+				
+				/* update points position */
+				gp_interpolate_update_points(gps_from, gps_to, new_stroke, factor);
+				
+				/* add to strokes */
+				BLI_addtail(&interFrame->strokes, new_stroke);
+			}
+		}
+	}
+	
+	/* notifiers */
+	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
+	
+	return OPERATOR_FINISHED;
+}
+
+void GPENCIL_OT_interpolate_sequence(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name = "Interpolate Sequence";
+	ot->idname = "GPENCIL_OT_interpolate_sequence";
+	ot->description = "Generate 'in-betweens' to smoothly interpolate between Grease Pencil frames";
+	
+	/* api callbacks */
+	ot->exec = gpencil_interpolate_seq_exec;
+	ot->poll = gpencil_interpolate_poll;
+	
+	/* flags */
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}
+
+/* ******************** Remove Breakdowns ************************ */
+
+/* Same as gpencil_interpolate_poll(), 
+ * except we ALSO need to have an active frame that is a breakdown
+ */
+static int gpencil_interpolate_reverse_poll(bContext *C)
+{
+	bGPdata *gpd = CTX_data_gpencil_data(C);
+	bGPDlayer *gpl = CTX_data_active_gpencil_layer(C);
+	
+	/* only 3D view */
+	if (CTX_wm_area(C)->spacetype != SPACE_VIEW3D) {
+		return 0;
+	}
+	
+	/* need data to interpolate */
+	if (ELEM(NULL, gpd, gpl)) {
+		return 0;
+	}
+	
+	/* need to be on a breakdown frame */
+	if ((gpl->actframe == NULL) || (gpl->actframe->key_type != BEZT_KEYTYPE_BREAKDOWN)) {
+		CTX_wm_operator_poll_msg_set(C, "Expected current frame to be a breakdown");
+		return 0;
+	}
+	
+	return 1;
+}
+
+static int gpencil_interpolate_reverse_exec(bContext *C, wmOperator *UNUSED(op))
+{
+	/* Go through each layer, deleting the breakdowns around the current frame,
+	 * but only if there is a keyframe nearby to stop at
+	 */
+	CTX_DATA_BEGIN(C, bGPDlayer *, gpl, editable_gpencil_layers)
+	{
+		bGPDframe *start_key = NULL;
+		bGPDframe *end_key = NULL;
+		bGPDframe *gpf, *gpfn;
+		
+		/* Only continue if we're currently on a breakdown keyframe */
+		if ((gpl->actframe == NULL) || (gpl->actframe->key_type != BEZT_KEYTYPE_BREAKDOWN))
+			continue;
+		
+		/* Search left for "start_key" (i.e. the first breakdown to remove) */
+		gpf = gpl->actframe;
+		while (gpf) {
+			if (gpf->key_type == BEZT_KEYTYPE_BREAKDOWN) {
+				/* A breakdown... keep going left */
+				start_key = gpf;
+				gpf = gpf->prev;
+			}
+			else {
+				/* Not a breakdown (may be a key, or an extreme, or something else that wasn't generated)... stop */
+				break;
+			}
+		}
+		
+		/* Search right for "end_key" (i.e. the last breakdown to remove) */
+		gpf = gpl->actframe;
+		while (gpf) {
+			if (gpf->key_type == BEZT_KEYTYPE_BREAKDOWN) {
+				/* A breakdown... keep going right */
+				end_key = gpf;
+				gpf = gpf->next;
+			}
+			else {
+				/* Not a breakdown... stop */
+				break;
+			}
+		}
+		
+		/* Did we find anything? */
+		/* NOTE: We should only proceed if there's something before/after these extents...
+		 * Otherwise, there's just an extent of breakdowns with no keys to interpolate between
+		 */
+		if ((start_key && end_key) && 
+		    ELEM(NULL, start_key->prev, end_key->next) == false)
+		{
+			/* Set actframe to the key before start_key, since the keys have been removed now */
+			gpl->actframe = start_key->prev;
+			
+			/* Free each frame we're removing (except the last one) */
+			for (gpf = start_key; gpf && gpf != end_key; gpf = gpfn) {
+				gpfn = gpf->next;
+				
+				/* free strokes and their associated memory */
+				BKE_gpencil_free_strokes(gpf);
+				BLI_freelinkN(&gpl->frames, gpf);
+			}
+			
+			/* Now free the last one... */
+			BKE_gpencil_free_strokes(end_key);
+			BLI_freelinkN(&gpl->frames, end_key);
+		}
+	}
+	CTX_DATA_END;
+	
+	/* notifiers */
+	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
+	
+	return OPERATOR_FINISHED;
+}
+
+void GPENCIL_OT_interpolate_reverse(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name = "Remove Breakdowns";
+	ot->idname = "GPENCIL_OT_interpolate_reverse";
+	ot->description = "Remove breakdown frames generated by interpolating between two Grease Pencil frames";
+	
+	/* callbacks */
+	ot->exec = gpencil_interpolate_reverse_exec;
+	ot->poll = gpencil_interpolate_reverse_poll;
+	
+	/* flags */
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}
+
+/* *************************************************************** */
diff --git a/source/blender/editors/gpencil/gpencil_ops.c b/source/blender/editors/gpencil/gpencil_ops.c
index 057d53ea458..78e1a0dda36 100644
--- a/source/blender/editors/gpencil/gpencil_ops.c
+++ b/source/blender/editors/gpencil/gpencil_ops.c
@@ -102,6 +102,10 @@ static void ed_keymap_gpencil_general(wmKeyConfig *keyconf)
 	WM_keymap_add_menu_pie(keymap, "GPENCIL_PIE_tool_palette", QKEY, KM_PRESS, 0, DKEY);
 	WM_keymap_add_menu_pie(keymap, "GPENCIL_PIE_settings_palette", WKEY, KM_PRESS, 0, DKEY);
 	
+	/* Add Blank Frame */
+	/* XXX: BKEY or NKEY? BKEY is easier to reach from DKEY, so we'll use that for now */
+	WM_keymap_add_item(keymap, "GPENCIL_OT_blank_frame_add", BKEY, KM_PRESS, 0, DKEY);
+	
 	/* Delete Active Frame - For easier video tutorials/review sessions */
 	/* NOTE: This works even when not in EditMode */
 	WM_keymap_add_item(keymap, "GPENCIL_OT_active_frames_delete_all", XKEY, KM_PRESS, 0, DKEY);
@@ -401,6 +405,8 @@ void ED_operatortypes_gpencil(void)
 	WM_operatortype_append(GPENCIL_OT_layer_isolate);
 	WM_operatortype_append(GPENCIL_OT_layer_merge);
 
+	WM_operatortype_append(GPENCIL_OT_blank_frame_add);
+	
 	WM_operatortype_append(GPENCIL_OT_active_frame_delete);
 	WM_operatortype_append(GPENCIL_OT_active_frames_delete_all);
 	
@@ -443,6 +449,7 @@ void ED_operatortypes_gpencil(void)
 	/* Interpolation */
 	WM_operatortype_append(GPENCIL_OT_interpolate);
 	WM_operatortype_append(GPENCIL_OT_interpolate_sequence);
+	WM_operatortype_append(GPENCIL_OT_interpolate_reverse);
 }
 
 void ED_operatormacros_gpencil(void)
diff --git a/source/blender/editors/gpencil/gpencil_paint.c b/source/blender/editors/gpencil/gpencil_paint.c
index b483402d6c8..73f393537ba 100644
--- a/source/blender/editors/gpencil/gpencil_paint.c
+++ b/source/blender/editors/gpencil/gpencil_paint.c
@@ -1625,16 +1625,24 @@ static void gp_paint_initstroke(tGPsdata *p, eGPencil_PaintModes paintmode)
 		 * 2) Ensure that p->gpf refers to the frame used for the active layer
 		 *    (to avoid problems with other tools which expect it to exist)
 		 */
-		bGPDlayer *gpl;
-		for (gpl = p->gpd->layers.first; gpl; gpl = gpl->next) {
+		bool has_layer_to_erase = false;
+		
+		for (bGPDlayer *gpl = p->gpd->layers.first; gpl; gpl = gpl->next) {
 			/* Skip if layer not editable */
 			if (gpencil_layer_is_editable(gpl) == false)
 				continue;
 			
 			/* Add a new frame if needed (and based off the active frame,
 			 * as we need some existing strokes to erase)
+			 *
+			 * Note: We don't add a new frame if there's nothing there now, so
+			 *       -> If there are no frames at all, don't add one
+			 *       -> If there are no strokes in that frame, don't add a new empty frame
 			 */
-			gpl->actframe = BKE_gpencil_layer_getframe(gpl, CFRA, GP_GETFRAME_ADD_COPY);
+			if (gpl->actframe && gpl->actframe->strokes.first) {
+				gpl->actframe = BKE_gpencil_layer_getframe(gpl, CFRA, GP_GETFRAME_ADD_COPY);
+				has_layer_to_erase = true;
+			}
 			
 			/* XXX: we omit GP_FRAME_PAINT here for now,
 			 * as it is only really useful for doing
@@ -1654,10 +1662,10 @@ static void gp_paint_initstroke(tGPsdata *p, eGPencil_PaintModes paintmode)
 			}
 		}
 		
-		if (p->gpf == NULL) {
+		if (has_layer_to_erase == false) {
 			p->status = GP_STATUS_ERROR;
 			//if (G.debug & G_DEBUG)
-				printf("Error: No frame created (gpencil_paint_init)\n");
+				printf("Error: Eraser will not be affecting anything (gpencil_paint_init)\n");
 			return;
 		}
 	}
@@ -2434,6 +2442,14 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
 			/* enable continuous if release D key in mid drawing */
 			p->scene->toolsettings->gpencil_flags |= GP_TOOL_FLAG_PAINTSESSIONS_ON;
 		}
+		else if ((event->type == BKEY) && (event->val == KM_RELEASE)) {
+			/* Add Blank Frame
+			 * - Since this operator is non-modal, we can just call it here, and keep going...
+	         * - This operator is especially useful when animating
+			 */
+			WM_operator_name_call(C, "GPENCIL_OT_blank_frame_add", WM_OP_EXEC_DEFAULT, NULL);
+			estate = OPERATOR_RUNNING_MODAL;
+		}
 		else {
 			estate = OPERATOR_RUNNING_MODAL;
 		}
@@ -2596,7 +2612,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
 			}
 			else if (p->status != GP_STATUS_ERROR) {
 				/* User clicked outside bounds of window while idling, so exit paintmode 
-				 * NOTE: Don't eter this case if an error occurred while finding the
+				 * NOTE: Don't enter this case if an error occurred while finding the
 				 *       region (as above)
 				 */
 				/* if drawing polygon and enable on back, must move stroke */
diff --git a/source/blender/editors/interface/interface.c b/source/blender/editors/interface/interface.c
index a913421d12c..682db20af55 100644
--- a/source/blender/editors/interface/interface.c
+++ b/source/blender/editors/interface/interface.c
@@ -1993,7 +1993,7 @@ uiBut *ui_but_drag_multi_edit_get(uiBut *but)
 static bool ui_but_icon_extra_is_visible_text_clear(const uiBut *but)
 {
 	BLI_assert(but->type == UI_BTYPE_TEXT);
-	return ((but->flag & UI_BUT_VALUE_CLEAR) && but->drawstr && but->drawstr[0]);
+	return ((but->flag & UI_BUT_VALUE_CLEAR) && but->drawstr[0]);
 }
 
 static bool ui_but_icon_extra_is_visible_search_unlink(const uiBut *but)
diff --git a/source/blender/editors/interface/interface_handlers.c b/source/blender/editors/interface/interface_handlers.c
index 241ac99edde..9bdc4d29807 100644
--- a/source/blender/editors/interface/interface_handlers.c
+++ b/source/blender/editors/interface/interface_handlers.c
@@ -2954,7 +2954,7 @@ static bool ui_textedit_copypaste(uiBut *but, uiHandleButtonData *data, const in
 
 		if (pbuf) {
 			if (ui_but_is_utf8(but)) {
-				buf_len -= BLI_utf8_invalid_strip(pbuf, buf_len);
+				buf_len -= BLI_utf8_invalid_strip(pbuf, (size_t)buf_len);
 			}
 
 			ui_textedit_insert_buf(but, data, pbuf, buf_len);
diff --git a/source/blender/editors/mesh/editmesh_tools.c b/source/blender/editors/mesh/editmesh_tools.c
index c57b0215d46..8f004bcf72b 100644
--- a/source/blender/editors/mesh/editmesh_tools.c
+++ b/source/blender/editors/mesh/editmesh_tools.c
@@ -684,27 +684,38 @@ static void edbm_add_edge_face_exec__tricky_finalize_sel(BMesh *bm, BMElem *ele_
 	/* now we need to find the edge that isnt connected to this element */
 	BM_select_history_clear(bm);
 
+	/* Notes on hidden geometry:
+	 * - un-hide the face since its possible hidden was copied when copying surrounding face attributes.
+	 * - un-hide before adding to select history
+	 *   since we may extend into an existing, hidden vert/edge.
+	 */
+
+	BM_elem_flag_disable(f, BM_ELEM_HIDDEN);
+	BM_face_select_set(bm, f, false);
+
 	if (ele_desel->head.htype == BM_VERT) {
 		BMLoop *l = BM_face_vert_share_loop(f, (BMVert *)ele_desel);
 		BLI_assert(f->len == 3);
-		BM_face_select_set(bm, f, false);
 		BM_vert_select_set(bm, (BMVert *)ele_desel, false);
-
 		BM_edge_select_set(bm, l->next->e, true);
 		BM_select_history_store(bm, l->next->e);
 	}
 	else {
 		BMLoop *l = BM_face_edge_share_loop(f, (BMEdge *)ele_desel);
 		BLI_assert(f->len == 4 || f->len == 3);
-		BM_face_select_set(bm, f, false);
+
 		BM_edge_select_set(bm, (BMEdge *)ele_desel, false);
 		if (f->len == 4) {
-			BM_edge_select_set(bm, l->next->next->e, true);
-			BM_select_history_store(bm, l->next->next->e);
+			BMEdge *e_active = l->next->next->e;
+			BM_elem_flag_disable(e_active, BM_ELEM_HIDDEN);
+			BM_edge_select_set(bm, e_active, true);
+			BM_select_history_store(bm, e_active);
 		}
 		else {
-			BM_vert_select_set(bm, l->next->next->v, true);
-			BM_select_history_store(bm, l->next->next->v);
+			BMVert *v_active = l->next->next->v;
+			BM_elem_flag_disable(v_active, BM_ELEM_HIDDEN);
+			BM_vert_select_set(bm, v_active, true);
+			BM_select_history_store(bm, v_active);
 		}
 	}
 }
@@ -758,6 +769,14 @@ static int edbm_add_edge_face_exec(bContext *C, wmOperator *op)
 	else
 #endif
 	{
+		/* Newly created faces may include existing hidden edges,
+		 * copying face data from surrounding, may have copied hidden face flag too.
+		 *
+		 * Important that faces use flushing since 'edges.out' wont include hidden edges that already existed.
+		 */
+		BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_HIDDEN, true);
+		BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_out, "edges.out", BM_EDGE, BM_ELEM_HIDDEN, false);
+
 		BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, true);
 		BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "edges.out", BM_EDGE, BM_ELEM_SELECT, true);
 	}
diff --git a/source/blender/editors/space_action/action_draw.c b/source/blender/editors/space_action/action_draw.c
index df9c67b1f2e..d82d38ac0eb 100644
--- a/source/blender/editors/space_action/action_draw.c
+++ b/source/blender/editors/space_action/action_draw.c
@@ -171,6 +171,8 @@ void draw_channel_strips(bAnimContext *ac, SpaceAction *saction, ARegion *ar)
 	unsigned char col1a[3], col2a[3];
 	unsigned char col1b[3], col2b[3];
 	
+	const bool show_group_colors = !(saction->flag & SACTION_NODRAWGCOLORS);
+	
 	
 	/* get theme colors */
 	UI_GetThemeColor3ubv(TH_BACK, col2);
@@ -254,8 +256,36 @@ void draw_channel_strips(bAnimContext *ac, SpaceAction *saction, ARegion *ar)
 						}
 						case ANIMTYPE_GROUP:
 						{
-							if (sel) immUniformColor4ub(col1a[0], col1a[1], col1a[2], 0x22);
-							else immUniformColor4ub(col2a[0], col2a[1], col2a[2], 0x22);
+							bActionGroup *agrp = ale->data;
+							if (show_group_colors && agrp->customCol) {
+								if (sel) {
+									unsigned char *cp = agrp->cs.select;
+									immUniformColor4ub(cp[0], cp[1], cp[2], 0x45);
+								}
+								else {
+									unsigned char *cp = agrp->cs.solid;
+									immUniformColor4ub(cp[0], cp[1], cp[2], 0x1D);
+								}
+							}
+							else {
+								if (sel) immUniformColor4ub(col1a[0], col1a[1], col1a[2], 0x22);
+								else immUniformColor4ub(col2a[0], col2a[1], col2a[2], 0x22);
+							}
+							break;
+						}
+						case ANIMTYPE_FCURVE:
+						{
+							FCurve *fcu = ale->data;
+							if (show_group_colors && fcu->grp && fcu->grp->customCol) {
+								unsigned char *cp = fcu->grp->cs.active;
+								
+								if (sel) immUniformColor4ub(cp[0], cp[1], cp[2], 0x65);
+								else immUniformColor4ub(cp[0], cp[1], cp[2], 0x0B);
+							}
+							else {
+								if (sel) immUniformColor4ub(col1[0], col1[1], col1[2], 0x22);
+								else immUniformColor4ub(col2[0], col2[1], col2[2], 0x22);
+							}
 							break;
 						}
 						default:
diff --git a/source/blender/editors/space_view3d/drawanimviz.c b/source/blender/editors/space_view3d/drawanimviz.c
index cf738de0202..f0e65f84205 100644
--- a/source/blender/editors/space_view3d/drawanimviz.c
+++ b/source/blender/editors/space_view3d/drawanimviz.c
@@ -75,6 +75,80 @@ void draw_motion_paths_init(View3D *v3d, ARegion *ar)
 	glLoadMatrixf(rv3d->viewmat);
 }
 
+/* set color
+* - more intense for active/selected bones, less intense for unselected bones
+* - black for before current frame, green for current frame, blue for after current frame
+* - intensity decreases as distance from current frame increases
+*
+* If the user select custom color, the color is replaced for the color selected in UI panel
+* - 75% Darker color is used for previous frames
+* - 50% Darker color for current frame
+* - User selected color for next frames
+*/
+static void set_motion_path_color(Scene *scene, bMotionPath *mpath, int i, short sel, int sfra, int efra,
+	float prev_color[3], float frame_color[3], float next_color[3])
+{
+	int frame = sfra + i;
+	int blend_base = (abs(frame - CFRA) == 1) ? TH_CFRAME : TH_BACK; /* "bleed" cframe color to ease color blending */
+
+#define SET_INTENSITY(A, B, C, min, max) (((1.0f - ((C - B) / (C - A))) * (max - min)) + min)
+	float intensity;  /* how faint */
+
+	if (frame < CFRA) {
+		if (mpath->flag & MOTIONPATH_FLAG_CUSTOM) {
+			/* Custom color: previous frames color is darker than current frame */
+			glColor3fv(prev_color);  
+		}
+		else {
+			/* black - before cfra */
+			if (sel) {
+				/* intensity = 0.5f; */
+				intensity = SET_INTENSITY(sfra, i, CFRA, 0.25f, 0.75f);
+			}
+			else {
+				/* intensity = 0.8f; */
+				intensity = SET_INTENSITY(sfra, i, CFRA, 0.68f, 0.92f);
+			}
+			UI_ThemeColorBlend(TH_WIRE, blend_base, intensity);
+		}
+	}
+	else if (frame > CFRA) {
+		if (mpath->flag & MOTIONPATH_FLAG_CUSTOM) {
+			/* Custom color: next frames color is equal to user selected color */
+			glColor3fv(next_color);  
+		}
+		else {
+			/* blue - after cfra */
+			if (sel) {
+				/* intensity = 0.5f; */
+				intensity = SET_INTENSITY(CFRA, i, efra, 0.25f, 0.75f);
+			}
+			else {
+				/* intensity = 0.8f; */
+				intensity = SET_INTENSITY(CFRA, i, efra, 0.68f, 0.92f);
+			}
+			UI_ThemeColorBlend(TH_BONE_POSE, blend_base, intensity);
+		}
+	}
+	else {
+		if (mpath->flag & MOTIONPATH_FLAG_CUSTOM) {
+			/* Custom color: current frame color is slightly darker than user selected color */
+			glColor3fv(frame_color);  
+		}
+		else {
+			/* green - on cfra */
+			if (sel) {
+				intensity = 0.5f;
+			}
+			else {
+				intensity = 0.99f;
+			}
+			UI_ThemeColorBlendShade(TH_CFRAME, TH_BACK, intensity, 10);
+		}
+	}
+#undef SET_INTENSITY
+}
+
 /* Draw the given motion path for an Object or a Bone 
  *  - assumes that the viewport has already been initialized properly
  *    i.e. draw_motion_paths_init() has been called
@@ -86,6 +160,28 @@ void draw_motion_path_instance(Scene *scene,
 	bMotionPathVert *mpv, *mpv_start;
 	int i, stepsize = avs->path_step;
 	int sfra, efra, sind, len;
+	float prev_color[3];
+	float frame_color[3];
+	float next_color[3];
+
+	/* Custom color - Previous frames: color is darker than current frame */
+	prev_color[0] = mpath->color[0] * 0.25f;
+	prev_color[1] = mpath->color[1] * 0.25f;
+	prev_color[2] = mpath->color[2] * 0.25f;
+
+	/* Custom color - Current frame: color is slightly darker than user selected color */
+	frame_color[0] = mpath->color[0] * 0.50f;
+	frame_color[1] = mpath->color[1] * 0.50f;
+	frame_color[2] = mpath->color[2] * 0.50f;
+
+	/* Custom color - Next frames: color is equal to user selection */
+	next_color[0] = mpath->color[0];
+	next_color[1] = mpath->color[1];
+	next_color[2] = mpath->color[2];
+
+	/* Save old line width */
+	GLfloat old_width;
+	glGetFloatv(GL_LINE_WIDTH, &old_width);
 	
 	/* get frame ranges */
 	if (avs->path_type == MOTIONPATH_TYPE_ACFRA) {
@@ -130,64 +226,27 @@ void draw_motion_path_instance(Scene *scene,
 	mpv_start = (mpath->points + sind);
 	
 	/* draw curve-line of path */
-	
-	glBegin(GL_LINE_STRIP);
-	for (i = 0, mpv = mpv_start; i < len; i++, mpv++) {
-		short sel = (pchan) ? (pchan->bone->flag & BONE_SELECTED) : (ob->flag & SELECT);
-		float intensity;  /* how faint */
-		
-		int frame = sfra + i;
-		int blend_base = (abs(frame - CFRA) == 1) ? TH_CFRAME : TH_BACK; /* "bleed" cframe color to ease color blending */
-		
-		/* set color
-		 * - more intense for active/selected bones, less intense for unselected bones
-		 * - black for before current frame, green for current frame, blue for after current frame
-		 * - intensity decreases as distance from current frame increases
-		 */
-#define SET_INTENSITY(A, B, C, min, max) (((1.0f - ((C - B) / (C - A))) * (max - min)) + min)
-		if (frame < CFRA) {
-			/* black - before cfra */
-			if (sel) {
-				/* intensity = 0.5f; */
-				intensity = SET_INTENSITY(sfra, i, CFRA, 0.25f, 0.75f);
-			}
-			else {
-				/* intensity = 0.8f; */
-				intensity = SET_INTENSITY(sfra, i, CFRA, 0.68f, 0.92f);
-			}
-			UI_ThemeColorBlend(TH_WIRE, blend_base, intensity);
-		}
-		else if (frame > CFRA) {
-			/* blue - after cfra */
-			if (sel) {
-				/* intensity = 0.5f; */
-				intensity = SET_INTENSITY(CFRA, i, efra, 0.25f, 0.75f);
-			}
-			else {
-				/* intensity = 0.8f; */
-				intensity = SET_INTENSITY(CFRA, i, efra, 0.68f, 0.92f);
-			}
-			UI_ThemeColorBlend(TH_BONE_POSE, blend_base, intensity);
-		}
-		else {
-			/* green - on cfra */
-			if (sel) {
-				intensity = 0.5f;
-			}
-			else {
-				intensity = 0.99f;
-			}
-			UI_ThemeColorBlendShade(TH_CFRAME, TH_BACK, intensity, 10);
+	/* Draw lines only if line drawing option is enabled */
+	if (mpath->flag & MOTIONPATH_FLAG_LINES) {
+		/* set line thickness */
+		glLineWidth(mpath->line_thickness);
+
+		glBegin(GL_LINE_STRIP);
+		for (i = 0, mpv = mpv_start; i < len; i++, mpv++) {
+			short sel = (pchan) ? (pchan->bone->flag & BONE_SELECTED) : (ob->flag & SELECT);
+			/* Set color */
+			set_motion_path_color(scene, mpath, i, sel, sfra, efra, prev_color, frame_color, next_color);
+			/* draw a vertex with this color */
+			glVertex3fv(mpv->co);
 		}
-#undef SET_INTENSITY
 
-		/* draw a vertex with this color */
-		glVertex3fv(mpv->co);
+		glEnd();
+		/* back to old line thickness */
+		glLineWidth(old_width);
 	}
-	
-	glEnd();
-	
-	glPointSize(1.0);
+
+	/* Point must be bigger than line thickness */
+	glPointSize(mpath->line_thickness + 1.0);
 	
 	/* draw little black point at each frame
 	 * NOTE: this is not really visible/noticeable
@@ -197,8 +256,13 @@ void draw_motion_path_instance(Scene *scene,
 		glVertex3fv(mpv->co);
 	glEnd();
 	
-	/* Draw little white dots at each framestep value */
-	UI_ThemeColor(TH_TEXT_HI);
+	/* Draw little white dots at each framestep value or replace with custom color */
+	if (mpath->flag & MOTIONPATH_FLAG_CUSTOM) {
+		glColor4fv(mpath->color);
+	}
+	else {
+		UI_ThemeColor(TH_TEXT_HI);
+	}
 	glBegin(GL_POINTS);
 	for (i = 0, mpv = mpv_start; i < len; i += stepsize, mpv += stepsize)
 		glVertex3fv(mpv->co);
@@ -208,11 +272,11 @@ void draw_motion_path_instance(Scene *scene,
 	 * NOTE: this is only done when keyframes are shown, since this adds similar types of clutter
 	 */
 	if ((avs->path_viewflag & MOTIONPATH_VIEW_KFRAS) &&
-	    (sfra < CFRA) && (CFRA <= efra))
+	    (sfra < CFRA) && (CFRA <= efra)) 
 	{
 		UI_ThemeColor(TH_CFRAME);
-		glPointSize(6.0f);
 		
+		glPointSize(mpath->line_thickness + 5.0);
 		glBegin(GL_POINTS);
 		mpv = mpv_start + (CFRA - sfra);
 		glVertex3fv(mpv->co);
@@ -289,7 +353,13 @@ void draw_motion_path_instance(Scene *scene,
 		UI_GetThemeColor3ubv(TH_VERTEX_SELECT, col);
 		col[3] = 255;
 		
-		glPointSize(4.0f);
+		/* if custom, point must be bigger than line */
+		if (mpath->flag & MOTIONPATH_FLAG_CUSTOM) {
+			glPointSize(mpath->line_thickness + 3.0);
+		}
+		else {
+			glPointSize(4.0f);
+		}
 		glColor3ubv(col);
 		
 		glBegin(GL_POINTS);
diff --git a/source/blender/editors/space_view3d/drawarmature.c b/source/blender/editors/space_view3d/drawarmature.c
index 7ac176f82b1..af041e392c5 100644
--- a/source/blender/editors/space_view3d/drawarmature.c
+++ b/source/blender/editors/space_view3d/drawarmature.c
@@ -2459,6 +2459,10 @@ static void draw_ghost_poses_range(Scene *scene, View3D *v3d, ARegion *ar, Base
 	if (end <= start)
 		return;
 	
+	/* prevent infinite loops if this is set to 0 - T49527 */
+	if (arm->ghostsize < 1)
+		arm->ghostsize = 1;
+	
 	stepsize = (float)(arm->ghostsize);
 	range = (float)(end - start);
 	
@@ -2604,7 +2608,11 @@ static void draw_ghost_poses(Scene *scene, View3D *v3d, ARegion *ar, Base *base)
 	calc_action_range(adt->action, &start, &end, 0);
 	if (start == end)
 		return;
-
+	
+	/* prevent infinite loops if this is set to 0 - T49527 */
+	if (arm->ghostsize < 1)
+		arm->ghostsize = 1;
+	
 	stepsize = (float)(arm->ghostsize);
 	range = (float)(arm->ghostep) * stepsize + 0.5f;   /* plus half to make the for loop end correct */
 	
diff --git a/source/blender/editors/transform/transform.c b/source/blender/editors/transform/transform.c
index 6a21592db22..751d750d5ac 100644
--- a/source/blender/editors/transform/transform.c
+++ b/source/blender/editors/transform/transform.c
@@ -2187,7 +2187,7 @@ bool initTransform(bContext *C, TransInfo *t, wmOperator *op, const wmEvent *eve
 	calculateCenter(t);
 
 	if (event) {
-		initMouseInput(t, &t->mouse, t->center2d, event->mval);
+		initMouseInput(t, &t->mouse, t->center2d, event->mval, event->shift);
 	}
 
 	switch (mode) {
@@ -8511,7 +8511,7 @@ static void initTimeScale(TransInfo *t)
 	center[1] = t->mouse.imval[1];
 
 	/* force a reinit with the center2d used here */
-	initMouseInput(t, &t->mouse, center, t->mouse.imval);
+	initMouseInput(t, &t->mouse, center, t->mouse.imval, false);
 
 	initMouseInputMode(t, &t->mouse, INPUT_SPRING_FLIP);
 
diff --git a/source/blender/editors/transform/transform.h b/source/blender/editors/transform/transform.h
index a59f9dc43dd..7ea4448a44e 100644
--- a/source/blender/editors/transform/transform.h
+++ b/source/blender/editors/transform/transform.h
@@ -728,7 +728,7 @@ typedef enum {
 	INPUT_CUSTOM_RATIO_FLIP,
 } MouseInputMode;
 
-void initMouseInput(TransInfo *t, MouseInput *mi, const float center[2], const int mval[2]);
+void initMouseInput(TransInfo *t, MouseInput *mi, const float center[2], const int mval[2], const bool precision);
 void initMouseInputMode(TransInfo *t, MouseInput *mi, MouseInputMode mode);
 eRedrawFlag handleMouseInput(struct TransInfo *t, struct MouseInput *mi, const struct wmEvent *event);
 void applyMouseInput(struct TransInfo *t, struct MouseInput *mi, const int mval[2], float output[3]);
diff --git a/source/blender/editors/transform/transform_input.c b/source/blender/editors/transform/transform_input.c
index 9b7d19eacd5..42cc918ec8c 100644
--- a/source/blender/editors/transform/transform_input.c
+++ b/source/blender/editors/transform/transform_input.c
@@ -234,10 +234,10 @@ static void InputAngleSpring(TransInfo *t, MouseInput *mi, const double mval[2],
 	output[1] = toutput[0];
 }
 
-void initMouseInput(TransInfo *UNUSED(t), MouseInput *mi, const float center[2], const int mval[2])
+void initMouseInput(TransInfo *UNUSED(t), MouseInput *mi, const float center[2], const int mval[2], const bool precision)
 {
 	mi->factor = 0;
-	mi->precision = 0;
+	mi->precision = precision;
 
 	mi->center[0] = center[0];
 	mi->center[1] = center[1];
diff --git a/source/blender/gpu/shaders/gpu_shader_material.glsl b/source/blender/gpu/shaders/gpu_shader_material.glsl
index 4416b6494f9..aa583c5ecf8 100644
--- a/source/blender/gpu/shaders/gpu_shader_material.glsl
+++ b/source/blender/gpu/shaders/gpu_shader_material.glsl
@@ -1358,7 +1358,7 @@ void mtex_cube_map_refl_from_refldir(
         samplerCube ima, vec3 reflecteddirection, out float value, out vec4 color)
 {
         color = textureCube(ima, reflecteddirection);
-        value = 1.0;
+        value = color.a;
 }
 
 void mtex_cube_map_refl(
diff --git a/source/blender/makesdna/DNA_action_types.h b/source/blender/makesdna/DNA_action_types.h
index f3df9090d41..1083400ece2 100644
--- a/source/blender/makesdna/DNA_action_types.h
+++ b/source/blender/makesdna/DNA_action_types.h
@@ -76,6 +76,8 @@ typedef struct bMotionPath {
 	int start_frame;            /* for drawing paths, the start frame number */
 	int end_frame;              /* for drawing paths, the end frame number */
 	
+	float color[3];	            /* optional custom color */
+	int line_thickness;         /* line thickness */
 	int flag;                   /* baking settings - eMotionPath_Flag */
 } bMotionPath;
 
@@ -84,7 +86,11 @@ typedef enum eMotionPath_Flag {
 	/* (for bones) path represents the head of the bone */
 	MOTIONPATH_FLAG_BHEAD       = (1 << 0),
 	/* motion path is being edited */
-	MOTIONPATH_FLAG_EDIT        = (1 << 1)
+	MOTIONPATH_FLAG_EDIT        = (1 << 1),
+	/* Custom colors */
+	MOTIONPATH_FLAG_CUSTOM      = (1 << 2),
+	/* Draw lines or only points */
+	MOTIONPATH_FLAG_LINES       = (1 << 3)   
 } eMotionPath_Flag;
 
 /* Visualization General --------------------------- */
diff --git a/source/blender/makesdna/DNA_scene_types.h b/source/blender/makesdna/DNA_scene_types.h
index f5e71ae59a9..8ee15ef21a3 100644
--- a/source/blender/makesdna/DNA_scene_types.h
+++ b/source/blender/makesdna/DNA_scene_types.h
@@ -1212,12 +1212,51 @@ typedef enum eGP_BrushEdit_SettingsFlag {
 	GP_BRUSHEDIT_FLAG_APPLY_STRENGTH = (1 << 2),
 	/* apply brush to thickness */
 	GP_BRUSHEDIT_FLAG_APPLY_THICKNESS = (1 << 3),
+} eGP_BrushEdit_SettingsFlag;
+
+
+/* Settings for GP Interpolation Operators */
+typedef struct GP_Interpolate_Settings {
+	short flag;                        /* eGP_Interpolate_SettingsFlag */
+	
+	char type;                         /* eGP_Interpolate_Type - Interpolation Mode */ 
+	char easing;                       /* eBezTriple_Easing - Easing mode (if easing equation used) */
+	
+	float back;                        /* BEZT_IPO_BACK */
+	float amplitude, period;           /* BEZT_IPO_ELASTIC */
+	
+	struct CurveMapping *custom_ipo;   /* custom interpolation curve (for use with GP_IPO_CURVEMAP) */
+} GP_Interpolate_Settings;
+
+/* GP_Interpolate_Settings.flag */
+typedef enum eGP_Interpolate_SettingsFlag {
 	/* apply interpolation to all layers */
-	GP_BRUSHEDIT_FLAG_INTERPOLATE_ALL_LAYERS = (1 << 4),
+	GP_TOOLFLAG_INTERPOLATE_ALL_LAYERS    = (1 << 0),
 	/* apply interpolation to only selected */
-	GP_BRUSHEDIT_FLAG_INTERPOLATE_ONLY_SELECTED = (1 << 5)
+	GP_TOOLFLAG_INTERPOLATE_ONLY_SELECTED = (1 << 1),
+} eGP_Interpolate_SettingsFlag;
+
+/* GP_Interpolate_Settings.type */
+typedef enum eGP_Interpolate_Type {
+	/* Traditional Linear Interpolation */
+	GP_IPO_LINEAR   = 0,
+	
+	/* CurveMap Defined Interpolation */
+	GP_IPO_CURVEMAP = 1,
+	
+	/* Easing Equations */
+	GP_IPO_BACK = 3,
+	GP_IPO_BOUNCE = 4,
+	GP_IPO_CIRC = 5,
+	GP_IPO_CUBIC = 6,
+	GP_IPO_ELASTIC = 7,
+	GP_IPO_EXPO = 8,
+	GP_IPO_QUAD = 9,
+	GP_IPO_QUART = 10,
+	GP_IPO_QUINT = 11,
+	GP_IPO_SINE = 12,
+} eGP_Interpolate_Type;
 
-} eGP_BrushEdit_SettingsFlag;
 
 /* *************************************************************** */
 /* Transform Orientations */
@@ -1435,7 +1474,10 @@ typedef struct ToolSettings {
 	
 	/* Grease Pencil Sculpt */
 	struct GP_BrushEdit_Settings gp_sculpt;
-
+	
+	/* Grease Pencil Interpolation Tool(s) */
+	struct GP_Interpolate_Settings gp_interpolate;
+	
 	/* Grease Pencil Drawing Brushes (bGPDbrush) */
 	ListBase gp_brushes; 
 
diff --git a/source/blender/makesrna/RNA_access.h b/source/blender/makesrna/RNA_access.h
index f97a5735c94..66e6f30feeb 100644
--- a/source/blender/makesrna/RNA_access.h
+++ b/source/blender/makesrna/RNA_access.h
@@ -262,6 +262,7 @@ extern StructRNA RNA_GPencilLayer;
 extern StructRNA RNA_GPencilPalette;
 extern StructRNA RNA_GPencilPaletteColor;
 extern StructRNA RNA_GPencilBrush;
+extern StructRNA RNA_GPencilInterpolateSettings;
 extern StructRNA RNA_GPencilStroke;
 extern StructRNA RNA_GPencilStrokePoint;
 extern StructRNA RNA_GPencilSculptSettings;
diff --git a/source/blender/makesrna/intern/rna_animviz.c b/source/blender/makesrna/intern/rna_animviz.c
index 8e42e68ed1e..eea24bfb1e0 100644
--- a/source/blender/makesrna/intern/rna_animviz.c
+++ b/source/blender/makesrna/intern/rna_animviz.c
@@ -153,7 +153,20 @@ static void rna_def_animviz_motion_path(BlenderRNA *brna)
 	prop = RNA_def_property(srna, "length", PROP_INT, PROP_TIME);
 	RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 	RNA_def_property_ui_text(prop, "Length", "Number of frames cached");
-	
+
+	/* Custom Color */
+	prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
+	RNA_def_property_array(prop, 3);
+	RNA_def_property_ui_text(prop, "Color", "Custom color for motion path");
+	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
+
+	/* Line width */
+	prop = RNA_def_property(srna, "line_thickness", PROP_INT, PROP_NONE);
+	RNA_def_property_int_sdna(prop, NULL, "line_thickness");
+	RNA_def_property_range(prop, 1, 6);
+	RNA_def_property_ui_text(prop, "Line thickness", "Line thickness for drawing path");
+	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
+
 	/* Settings */
 	prop = RNA_def_property(srna, "use_bone_head", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOTIONPATH_FLAG_BHEAD);
@@ -164,6 +177,19 @@ static void rna_def_animviz_motion_path(BlenderRNA *brna)
 	prop = RNA_def_property(srna, "is_modified", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOTIONPATH_FLAG_EDIT);
 	RNA_def_property_ui_text(prop, "Edit Path", "Path is being edited");
+
+	/* Use custom color */
+	prop = RNA_def_property(srna, "use_custom_color", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOTIONPATH_FLAG_CUSTOM);
+	RNA_def_property_ui_text(prop, "Custom colors", "Use custom color for this motion path");
+	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
+
+	/* Draw lines between keyframes */
+	prop = RNA_def_property(srna, "lines", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOTIONPATH_FLAG_LINES);
+	RNA_def_property_ui_text(prop, "Lines", "Draw straight lines between keyframe points");
+	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
+
 }
 
 /* --- */
@@ -337,6 +363,7 @@ static void rna_def_animviz_paths(BlenderRNA *brna)
 	                         "Number of frames to show after the current frame "
 	                         "(only for 'Around Current Frame' Onion-skinning method)");
 	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
+
 }
 
 /* --- */
diff --git a/source/blender/makesrna/intern/rna_gpencil.c b/source/blender/makesrna/intern/rna_gpencil.c
index 9c66a86dcee..25cd7265c3e 100644
--- a/source/blender/makesrna/intern/rna_gpencil.c
+++ b/source/blender/makesrna/intern/rna_gpencil.c
@@ -60,6 +60,7 @@ static EnumPropertyItem parent_type_items[] = {
 
 #include "WM_api.h"
 
+#include "BKE_animsys.h"
 #include "BKE_gpencil.h"
 #include "BKE_action.h"
 
@@ -353,10 +354,16 @@ static void rna_GPencilLayer_info_set(PointerRNA *ptr, const char *value)
 	bGPdata *gpd = ptr->id.data;
 	bGPDlayer *gpl = ptr->data;
 
+	char oldname[128] = "";
+	BLI_strncpy(oldname, gpl->info, sizeof(oldname));
+
 	/* copy the new name into the name slot */
 	BLI_strncpy_utf8(gpl->info, value, sizeof(gpl->info));
 
 	BLI_uniquename(&gpd->layers, gpl, DATA_("GP_Layer"), '.', offsetof(bGPDlayer, info), sizeof(gpl->info));
+
+	/* now fix animation paths */
+	BKE_animdata_fix_paths_rename_all(&gpd->id, "layers", oldname, gpl->info);
 }
 
 static void rna_GPencil_use_onion_skinning_set(PointerRNA *ptr, const int value)
@@ -814,14 +821,20 @@ static void rna_GPencilPaletteColor_info_set(PointerRNA *ptr, const char *value)
 	bGPdata *gpd = ptr->id.data;
 	bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
 	bGPDpalettecolor *palcolor = ptr->data;
-
-	/* rename all strokes */
-	BKE_gpencil_palettecolor_changename(gpd, palcolor->info, value);
+	
+	char oldname[64] = "";
+	BLI_strncpy(oldname, palcolor->info, sizeof(oldname));
 
 	/* copy the new name into the name slot */
 	BLI_strncpy_utf8(palcolor->info, value, sizeof(palcolor->info));
 	BLI_uniquename(&palette->colors, palcolor, DATA_("Color"), '.', offsetof(bGPDpalettecolor, info),
 	               sizeof(palcolor->info));
+	
+	/* rename all strokes */
+	BKE_gpencil_palettecolor_changename(gpd, oldname, palcolor->info);
+
+	/* now fix animation paths */
+	BKE_animdata_fix_paths_rename_all(&gpd->id, "colors", oldname, palcolor->info);
 }
 
 static void rna_GPencilStrokeColor_info_set(PointerRNA *ptr, const char *value)
diff --git a/source/blender/makesrna/intern/rna_scene.c b/source/blender/makesrna/intern/rna_scene.c
index 6947a4104c8..1166fb89a0a 100644
--- a/source/blender/makesrna/intern/rna_scene.c
+++ b/source/blender/makesrna/intern/rna_scene.c
@@ -407,9 +407,34 @@ EnumPropertyItem rna_enum_bake_pass_filter_type_items[] = {
 	{0, NULL, 0, NULL, NULL}
 };
 
+EnumPropertyItem rna_enum_gpencil_interpolation_mode_items[] = {
+	/* interpolation */
+	{0, "", 0, N_("Interpolation"), "Standard transitions between keyframes"},
+	{GP_IPO_LINEAR,   "LINEAR", ICON_IPO_LINEAR, "Linear", "Straight-line interpolation between A and B (i.e. no ease in/out)"},
+	{GP_IPO_CURVEMAP, "CUSTOM", ICON_IPO_BEZIER, "Custom", "Custom interpolation defined using a curvemap"},
+	
+	/* easing */
+	{0, "", 0, N_("Easing (by strength)"), "Predefined inertial transitions, useful for motion graphics (from least to most ''dramatic'')"},
+	{GP_IPO_SINE, "SINE", ICON_IPO_SINE, "Sinusoidal", "Sinusoidal easing (weakest, almost linear but with a slight curvature)"},
+	{GP_IPO_QUAD, "QUAD", ICON_IPO_QUAD, "Quadratic", "Quadratic easing"},
+	{GP_IPO_CUBIC, "CUBIC", ICON_IPO_CUBIC, "Cubic", "Cubic easing"},
+	{GP_IPO_QUART, "QUART", ICON_IPO_QUART, "Quartic", "Quartic easing"},
+	{GP_IPO_QUINT, "QUINT", ICON_IPO_QUINT, "Quintic", "Quintic easing"},
+	{GP_IPO_EXPO, "EXPO", ICON_IPO_EXPO, "Exponential", "Exponential easing (dramatic)"},
+	{GP_IPO_CIRC, "CIRC", ICON_IPO_CIRC, "Circular", "Circular easing (strongest and most dynamic)"},
+	
+	{0, "", 0, N_("Dynamic Effects"), "Simple physics-inspired easing effects"},
+	{GP_IPO_BACK, "BACK", ICON_IPO_BACK, "Back", "Cubic easing with overshoot and settle"},
+	{GP_IPO_BOUNCE, "BOUNCE", ICON_IPO_BOUNCE, "Bounce", "Exponentially decaying parabolic bounce, like when objects collide"},
+	{GP_IPO_ELASTIC, "ELASTIC", ICON_IPO_ELASTIC, "Elastic", "Exponentially decaying sine wave, like an elastic band"},
+	
+	{0, NULL, 0, NULL, NULL}
+};
+
 #ifdef RNA_RUNTIME
 
 #include "DNA_anim_types.h"
+#include "DNA_color_types.h"
 #include "DNA_node_types.h"
 #include "DNA_object_types.h"
 #include "DNA_mesh_types.h"
@@ -420,6 +445,7 @@ EnumPropertyItem rna_enum_bake_pass_filter_type_items[] = {
 #include "MEM_guardedalloc.h"
 
 #include "BKE_brush.h"
+#include "BKE_colortools.h"
 #include "BKE_context.h"
 #include "BKE_global.h"
 #include "BKE_image.h"
@@ -447,6 +473,29 @@ EnumPropertyItem rna_enum_bake_pass_filter_type_items[] = {
 #include "FRS_freestyle.h"
 #endif
 
+/* Grease Pencil Interpolation settings */
+static char *rna_GPencilInterpolateSettings_path(PointerRNA *UNUSED(ptr))
+{
+	return BLI_strdup("tool_settings.gpencil_interpolate");
+}
+
+static void rna_GPencilInterpolateSettings_type_set(PointerRNA *ptr, int value)
+{
+	GP_Interpolate_Settings *settings = (GP_Interpolate_Settings *)ptr->data;
+	
+	/* NOTE: This cast should be fine, as we have a small + finite set of values (eGP_Interpolate_Type)
+	 * that should fit well within a char
+	 */
+	settings->type = (char)value;
+	
+	/* init custom interpolation curve here now the first time it's used */
+	if ((settings->type == GP_IPO_CURVEMAP) &&
+	    (settings->custom_ipo == NULL))
+	{
+		settings->custom_ipo = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+	}
+}
+
 /* Grease pencil Drawing Brushes */
 static bGPDbrush *rna_GPencil_brush_new(ToolSettings *ts, const char *name, int setactive)
 {
@@ -2138,6 +2187,73 @@ static int rna_gpu_is_hq_supported_get(PointerRNA *UNUSED(ptr))
 
 #else
 
+/* Grease Pencil Interpolation tool settings */
+static void rna_def_gpencil_interpolate(BlenderRNA *brna)
+{
+	StructRNA *srna;
+	PropertyRNA *prop;
+	
+	srna = RNA_def_struct(brna, "GPencilInterpolateSettings", NULL);
+	RNA_def_struct_sdna(srna, "GP_Interpolate_Settings");
+	RNA_def_struct_path_func(srna, "rna_GPencilInterpolateSettings_path");
+	RNA_def_struct_ui_text(srna, "Grease Pencil Interpolate Settings",
+	                       "Settings for Grease Pencil interpolation tools");
+	
+	/* flags */
+	prop = RNA_def_property(srna, "interpolate_all_layers", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_TOOLFLAG_INTERPOLATE_ALL_LAYERS);
+	RNA_def_property_ui_text(prop, "Interpolate All Layers", "Interpolate all layers, not only active");
+	RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
+
+	prop = RNA_def_property(srna, "interpolate_selected_only", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_TOOLFLAG_INTERPOLATE_ONLY_SELECTED);
+	RNA_def_property_ui_text(prop, "Interpolate Selected Strokes", "Interpolate only selected strokes in the original frame");
+	RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
+	
+	/* interpolation type */
+	prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
+	RNA_def_property_enum_sdna(prop, NULL, "type");
+	RNA_def_property_enum_items(prop, rna_enum_gpencil_interpolation_mode_items);
+	RNA_def_property_enum_funcs(prop, NULL, "rna_GPencilInterpolateSettings_type_set", NULL);
+	RNA_def_property_ui_text(prop, "Type",
+	                         "Interpolation method to use the next time 'Interpolate Sequence' is run");
+	RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
+	
+	/* easing */
+	prop = RNA_def_property(srna, "easing", PROP_ENUM, PROP_NONE);
+	RNA_def_property_enum_sdna(prop, NULL, "easing");
+	RNA_def_property_enum_items(prop, rna_enum_beztriple_interpolation_easing_items);
+	RNA_def_property_ui_text(prop, "Easing", 
+	                         "Which ends of the segment between the preceding and following grease pencil frames "
+	                         "easing interpolation is applied to");
+	RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
+	
+	/* easing options */
+	prop = RNA_def_property(srna, "back", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_float_sdna(prop, NULL, "back");
+	RNA_def_property_ui_text(prop, "Back", "Amount of overshoot for 'back' easing");
+	RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
+	
+	prop = RNA_def_property(srna, "amplitude", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_float_sdna(prop, NULL, "amplitude");
+	RNA_def_property_range(prop, 0.0f, FLT_MAX); /* only positive values... */
+	RNA_def_property_ui_text(prop, "Amplitude", "Amount to boost elastic bounces for 'elastic' easing");
+	RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
+	
+	prop = RNA_def_property(srna, "period", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_float_sdna(prop, NULL, "period");
+	RNA_def_property_ui_text(prop, "Period", "Time between bounces for elastic easing");
+	RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
+	
+	/* custom curvemap */
+	prop = RNA_def_property(srna, "interpolation_curve", PROP_POINTER, PROP_NONE);
+	RNA_def_property_pointer_sdna(prop, NULL, "custom_ipo");
+	RNA_def_property_struct_type(prop, "CurveMapping");
+	RNA_def_property_ui_text(prop, "Interpolation Curve", 
+	                         "Custom curve to control 'sequence' interpolation between Grease Pencil frames");
+	RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
+}
+
 /* Grease Pencil Drawing Brushes */
 static void rna_def_gpencil_brush(BlenderRNA *brna)
 {
@@ -2673,7 +2789,14 @@ static void rna_def_tool_settings(BlenderRNA  *brna)
 	prop = RNA_def_property(srna, "gpencil_sculpt", PROP_POINTER, PROP_NONE);
 	RNA_def_property_pointer_sdna(prop, NULL, "gp_sculpt");
 	RNA_def_property_struct_type(prop, "GPencilSculptSettings");
-	RNA_def_property_ui_text(prop, "Grease Pencil Sculpt", "");
+	RNA_def_property_ui_text(prop, "Grease Pencil Sculpt",
+	                         "Settings for stroke sculpting tools and brushes");
+	
+	prop = RNA_def_property(srna, "gpencil_interpolate", PROP_POINTER, PROP_NONE);
+	RNA_def_property_pointer_sdna(prop, NULL, "gp_interpolate");
+	RNA_def_property_struct_type(prop, "GPencilInterpolateSettings");
+	RNA_def_property_ui_text(prop, "Grease Pencil Interpolate", 
+	                        "Settings for Grease Pencil Interpolation tools");
 
 	/* Grease Pencil - Drawing brushes */
 	prop = RNA_def_property(srna, "gpencil_brushes", PROP_COLLECTION, PROP_NONE);
@@ -7267,6 +7390,7 @@ void RNA_def_scene(BlenderRNA *brna)
 	RNA_define_animate_sdna(false);
 	rna_def_tool_settings(brna);
 	rna_def_gpencil_brush(brna);
+	rna_def_gpencil_interpolate(brna);
 	rna_def_unified_paint_settings(brna);
 	rna_def_curve_paint_settings(brna);
 	rna_def_statvis(brna);
diff --git a/source/blender/makesrna/intern/rna_sculpt_paint.c b/source/blender/makesrna/intern/rna_sculpt_paint.c
index 7f405f0fb1f..40aea37d9d2 100644
--- a/source/blender/makesrna/intern/rna_sculpt_paint.c
+++ b/source/blender/makesrna/intern/rna_sculpt_paint.c
@@ -1047,15 +1047,6 @@ static void rna_def_gpencil_sculpt(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Affect Thickness", "The brush affects the thickness of the point");
 	RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 
-	prop = RNA_def_property(srna, "interpolate_all_layers", PROP_BOOLEAN, PROP_NONE);
-	RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSHEDIT_FLAG_INTERPOLATE_ALL_LAYERS);
-	RNA_def_property_ui_text(prop, "Interpolate All Layers", "Interpolate all layers, not only active");
-	RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
-
-	prop = RNA_def_property(srna, "interpolate_selected_only", PROP_BOOLEAN, PROP_NONE);
-	RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSHEDIT_FLAG_INTERPOLATE_ONLY_SELECTED);
-	RNA_def_property_ui_text(prop, "Interpolate Selected Strokes", "Interpolate only selected strokes in the original frame");
-	RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 
 	prop = RNA_def_property(srna, "selection_alpha", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "alpha");
diff --git a/source/blender/nodes/shader/nodes/node_shader_light_path.c b/source/blender/nodes/shader/nodes/node_shader_light_path.c
index b1001cd3937..052f2a66ec8 100644
--- a/source/blender/nodes/shader/nodes/node_shader_light_path.c
+++ b/source/blender/nodes/shader/nodes/node_shader_light_path.c
@@ -39,6 +39,8 @@ static bNodeSocketTemplate sh_node_light_path_out[] = {
 	{	SOCK_FLOAT, 0, N_("Is Transmission Ray"),	0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
 	{	SOCK_FLOAT, 0, N_("Ray Length"),			0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
 	{	SOCK_FLOAT, 0, N_("Ray Depth"),				0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
+	{	SOCK_FLOAT, 0, N_("Diffuse Depth"),	0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
+	{	SOCK_FLOAT, 0, N_("Glossy Depth"),	0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
 	{	SOCK_FLOAT, 0, N_("Transparent Depth"),		0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
 	{	SOCK_FLOAT, 0, N_("Transmission Depth"),	0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
 	{	-1, 0, ""	}