Cycles: merge of changes from tomato branch.

Regular rendering now works tiled, and supports save buffers to save memory
during render and cache render results.

Brick texture node by Thomas.
http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Textures#Brick_Texture

Image texture Blended Box Mapping.
http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Textures#Image_Texture
http://mango.blender.org/production/blended_box/

Various bug fixes by Sergey and Campbell.
* Fix for reading freed memory in some node setups.
* Fix incorrect memory read when synchronizing mesh motion.
* Fix crash appearing when direct light usage is different on different layers.
* Fix for vector pass gives wrong result in some circumstances.
* Fix for wrong resolution used for rendering Render Layer node.
* Option to cancel rendering when doing initial synchronization.
* No more texture limit when using CPU render.
* Many fixes for new tiled rendering.

10 files changed, 269 insertions, 148 deletions

diff --git a/intern/cycles/kernel/CMakeLists.txt b/intern/cycles/kernel/CMakeLists.txt
index 98cb16d5dfc..c26954e23b6 100644
--- a/intern/cycles/kernel/CMakeLists.txt
+++ b/intern/cycles/kernel/CMakeLists.txt
@@ -61,6 +61,7 @@ set(SRC_SVM_HEADERS
 	svm/svm_closure.h
 	svm/svm_convert.h
 	svm/svm_checker.h
+	svm/svm_brick.h
 	svm/svm_displace.h
 	svm/svm_fresnel.h
 	svm/svm_gamma.h
diff --git a/intern/cycles/kernel/kernel.cpp b/intern/cycles/kernel/kernel.cpp
index 667db1e5f03..62d79bdd946 100644
--- a/intern/cycles/kernel/kernel.cpp
+++ b/intern/cycles/kernel/kernel.cpp
@@ -87,14 +87,10 @@ void kernel_tex_copy(KernelGlobals *kg, const char *name, device_ptr mem, size_t
 	else if(strstr(name, "__tex_image_float")) {
 		texture_image_float4 *tex = NULL;
 		int id = atoi(name + strlen("__tex_image_float_"));
+		int array_index = id;
 
-		switch(id) {
-			case 95: tex = &kg->__tex_image_float_095; break;
-			case 96: tex = &kg->__tex_image_float_096; break;
-			case 97: tex = &kg->__tex_image_float_097; break;
-			case 98: tex = &kg->__tex_image_float_098; break;
-			case 99: tex = &kg->__tex_image_float_099; break;
-			default: break;
+		if (array_index >= 0 && array_index < MAX_FLOAT_IMAGES) {
+			tex = &kg->texture_float_images[array_index];
 		}
 
 		if(tex) {
@@ -106,104 +102,10 @@ void kernel_tex_copy(KernelGlobals *kg, const char *name, device_ptr mem, size_t
 	else if(strstr(name, "__tex_image")) {
 		texture_image_uchar4 *tex = NULL;
 		int id = atoi(name + strlen("__tex_image_"));
+		int array_index = id - MAX_FLOAT_IMAGES;
 
-		switch(id) {
-			case 0: tex = &kg->__tex_image_000; break;
-			case 1: tex = &kg->__tex_image_001; break;
-			case 2: tex = &kg->__tex_image_002; break;
-			case 3: tex = &kg->__tex_image_003; break;
-			case 4: tex = &kg->__tex_image_004; break;
-			case 5: tex = &kg->__tex_image_005; break;
-			case 6: tex = &kg->__tex_image_006; break;
-			case 7: tex = &kg->__tex_image_007; break;
-			case 8: tex = &kg->__tex_image_008; break;
-			case 9: tex = &kg->__tex_image_009; break;
-			case 10: tex = &kg->__tex_image_010; break;
-			case 11: tex = &kg->__tex_image_011; break;
-			case 12: tex = &kg->__tex_image_012; break;
-			case 13: tex = &kg->__tex_image_013; break;
-			case 14: tex = &kg->__tex_image_014; break;
-			case 15: tex = &kg->__tex_image_015; break;
-			case 16: tex = &kg->__tex_image_016; break;
-			case 17: tex = &kg->__tex_image_017; break;
-			case 18: tex = &kg->__tex_image_018; break;
-			case 19: tex = &kg->__tex_image_019; break;
-			case 20: tex = &kg->__tex_image_020; break;
-			case 21: tex = &kg->__tex_image_021; break;
-			case 22: tex = &kg->__tex_image_022; break;
-			case 23: tex = &kg->__tex_image_023; break;
-			case 24: tex = &kg->__tex_image_024; break;
-			case 25: tex = &kg->__tex_image_025; break;
-			case 26: tex = &kg->__tex_image_026; break;
-			case 27: tex = &kg->__tex_image_027; break;
-			case 28: tex = &kg->__tex_image_028; break;
-			case 29: tex = &kg->__tex_image_029; break;
-			case 30: tex = &kg->__tex_image_030; break;
-			case 31: tex = &kg->__tex_image_031; break;
-			case 32: tex = &kg->__tex_image_032; break;
-			case 33: tex = &kg->__tex_image_033; break;
-			case 34: tex = &kg->__tex_image_034; break;
-			case 35: tex = &kg->__tex_image_035; break;
-			case 36: tex = &kg->__tex_image_036; break;
-			case 37: tex = &kg->__tex_image_037; break;
-			case 38: tex = &kg->__tex_image_038; break;
-			case 39: tex = &kg->__tex_image_039; break;
-			case 40: tex = &kg->__tex_image_040; break;
-			case 41: tex = &kg->__tex_image_041; break;
-			case 42: tex = &kg->__tex_image_042; break;
-			case 43: tex = &kg->__tex_image_043; break;
-			case 44: tex = &kg->__tex_image_044; break;
-			case 45: tex = &kg->__tex_image_045; break;
-			case 46: tex = &kg->__tex_image_046; break;
-			case 47: tex = &kg->__tex_image_047; break;
-			case 48: tex = &kg->__tex_image_048; break;
-			case 49: tex = &kg->__tex_image_049; break;
-			case 50: tex = &kg->__tex_image_050; break;
-			case 51: tex = &kg->__tex_image_051; break;
-			case 52: tex = &kg->__tex_image_052; break;
-			case 53: tex = &kg->__tex_image_053; break;
-			case 54: tex = &kg->__tex_image_054; break;
-			case 55: tex = &kg->__tex_image_055; break;
-			case 56: tex = &kg->__tex_image_056; break;
-			case 57: tex = &kg->__tex_image_057; break;
-			case 58: tex = &kg->__tex_image_058; break;
-			case 59: tex = &kg->__tex_image_059; break;
-			case 60: tex = &kg->__tex_image_060; break;
-			case 61: tex = &kg->__tex_image_061; break;
-			case 62: tex = &kg->__tex_image_062; break;
-			case 63: tex = &kg->__tex_image_063; break;
-			case 64: tex = &kg->__tex_image_064; break;
-			case 65: tex = &kg->__tex_image_065; break;
-			case 66: tex = &kg->__tex_image_066; break;
-			case 67: tex = &kg->__tex_image_067; break;
-			case 68: tex = &kg->__tex_image_068; break;
-			case 69: tex = &kg->__tex_image_069; break;
-			case 70: tex = &kg->__tex_image_070; break;
-			case 71: tex = &kg->__tex_image_071; break;
-			case 72: tex = &kg->__tex_image_072; break;
-			case 73: tex = &kg->__tex_image_073; break;
-			case 74: tex = &kg->__tex_image_074; break;
-			case 75: tex = &kg->__tex_image_075; break;
-			case 76: tex = &kg->__tex_image_076; break;
-			case 77: tex = &kg->__tex_image_077; break;
-			case 78: tex = &kg->__tex_image_078; break;
-			case 79: tex = &kg->__tex_image_079; break;
-			case 80: tex = &kg->__tex_image_080; break;
-			case 81: tex = &kg->__tex_image_081; break;
-			case 82: tex = &kg->__tex_image_082; break;
-			case 83: tex = &kg->__tex_image_083; break;
-			case 84: tex = &kg->__tex_image_084; break;
-			case 85: tex = &kg->__tex_image_085; break;
-			case 86: tex = &kg->__tex_image_086; break;
-			case 87: tex = &kg->__tex_image_087; break;
-			case 88: tex = &kg->__tex_image_088; break;
-			case 89: tex = &kg->__tex_image_089; break;
-			case 90: tex = &kg->__tex_image_090; break;
-			case 91: tex = &kg->__tex_image_091; break;
-			case 92: tex = &kg->__tex_image_092; break;
-			case 93: tex = &kg->__tex_image_093; break;
-			case 94: tex = &kg->__tex_image_094; break;
-			default: break;
+		if (array_index >= 0 && array_index < MAX_BYTE_IMAGES) {
+			tex = &kg->texture_byte_images[array_index];
 		}
 
 		if(tex) {
diff --git a/intern/cycles/kernel/kernel_compat_cpu.h b/intern/cycles/kernel/kernel_compat_cpu.h
index cc8f1f3323b..45f653a686c 100644
--- a/intern/cycles/kernel/kernel_compat_cpu.h
+++ b/intern/cycles/kernel/kernel_compat_cpu.h
@@ -158,7 +158,7 @@ typedef texture_image<uchar4> texture_image_uchar4;
 #define kernel_tex_fetch_m128(tex, index) (kg->tex.fetch_m128(index))
 #define kernel_tex_fetch_m128i(tex, index) (kg->tex.fetch_m128i(index))
 #define kernel_tex_interp(tex, t, size) (kg->tex.interp(t, size))
-#define kernel_tex_image_interp(tex, x, y) (kg->tex.interp(x, y))
+#define kernel_tex_image_interp(tex, x, y) ((tex < MAX_FLOAT_IMAGES) ? kg->texture_float_images[tex].interp(x, y) : kg->texture_byte_images[tex - MAX_FLOAT_IMAGES].interp(x, y))
 
 #define kernel_data (kg->__data)
 
diff --git a/intern/cycles/kernel/kernel_globals.h b/intern/cycles/kernel/kernel_globals.h
index a99fffbc519..1e56c11ab90 100644
--- a/intern/cycles/kernel/kernel_globals.h
+++ b/intern/cycles/kernel/kernel_globals.h
@@ -35,10 +35,15 @@ CCL_NAMESPACE_BEGIN
 
 #ifdef __KERNEL_CPU__
 
+#define MAX_BYTE_IMAGES   512
+#define MAX_FLOAT_IMAGES  5
+
 typedef struct KernelGlobals {
+	texture_image_uchar4 texture_byte_images[MAX_BYTE_IMAGES];
+	texture_image_float4 texture_float_images[MAX_FLOAT_IMAGES];
 
 #define KERNEL_TEX(type, ttype, name) ttype name;
-#define KERNEL_IMAGE_TEX(type, ttype, name) ttype name;
+#define KERNEL_IMAGE_TEX(type, ttype, name)
 #include "kernel_textures.h"
 
 	KernelData __data;
diff --git a/intern/cycles/kernel/kernel_path.h b/intern/cycles/kernel/kernel_path.h
index fc67ca98039..8e3a0c6e628 100644
--- a/intern/cycles/kernel/kernel_path.h
+++ b/intern/cycles/kernel/kernel_path.h
@@ -689,7 +689,7 @@ __device float4 kernel_path_non_progressive(KernelGlobals *kg, RNG *rng, int sam
 		if(kernel_data.integrator.use_ambient_occlusion) {
 			int num_samples = kernel_data.integrator.ao_samples;
 			float num_samples_inv = 1.0f/num_samples;
-			float ao_factor = kernel_data.background.ao_factor/num_samples;
+			float ao_factor = kernel_data.background.ao_factor;
 
 			for(int j = 0; j < num_samples; j++) {
 				/* todo: solve correlation */
diff --git a/intern/cycles/kernel/kernel_textures.h b/intern/cycles/kernel/kernel_textures.h
index c1b8eed3dff..4855a948c6e 100644
--- a/intern/cycles/kernel/kernel_textures.h
+++ b/intern/cycles/kernel/kernel_textures.h
@@ -66,12 +66,14 @@ KERNEL_TEX(float, texture_float, __filter_table)
 /* sobol */
 KERNEL_TEX(uint, texture_uint, __sobol_directions)
 
+/* full-float image */
+KERNEL_IMAGE_TEX(float4, texture_image_float4, __tex_image_float_000)
+KERNEL_IMAGE_TEX(float4, texture_image_float4, __tex_image_float_001)
+KERNEL_IMAGE_TEX(float4, texture_image_float4, __tex_image_float_002)
+KERNEL_IMAGE_TEX(float4, texture_image_float4, __tex_image_float_003)
+KERNEL_IMAGE_TEX(float4, texture_image_float4, __tex_image_float_004)
+
 /* image */
-KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_000)
-KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_001)
-KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_002)
-KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_003)
-KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_004)
 KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_005)
 KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_006)
 KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_007)
@@ -162,13 +164,11 @@ KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_091)
 KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_092)
 KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_093)
 KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_094)
-
-/* full-float image */
-KERNEL_IMAGE_TEX(float4, texture_image_float4, __tex_image_float_095)
-KERNEL_IMAGE_TEX(float4, texture_image_float4, __tex_image_float_096)
-KERNEL_IMAGE_TEX(float4, texture_image_float4, __tex_image_float_097)
-KERNEL_IMAGE_TEX(float4, texture_image_float4, __tex_image_float_098)
-KERNEL_IMAGE_TEX(float4, texture_image_float4, __tex_image_float_099)
+KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_095)
+KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_096)
+KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_097)
+KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_098)
+KERNEL_IMAGE_TEX(uchar4, texture_image_uchar4, __tex_image_099)
 
 /* packed image (opencl) */
 KERNEL_TEX(uchar4, texture_uchar4, __tex_image_packed)
diff --git a/intern/cycles/kernel/svm/svm.h b/intern/cycles/kernel/svm/svm.h
index 8901e5e9628..5b0f192ea47 100644
--- a/intern/cycles/kernel/svm/svm.h
+++ b/intern/cycles/kernel/svm/svm.h
@@ -154,6 +154,7 @@ CCL_NAMESPACE_END
 #include "svm_value.h"
 #include "svm_voronoi.h"
 #include "svm_checker.h"
+#include "svm_brick.h"
 
 CCL_NAMESPACE_BEGIN
 
@@ -220,6 +221,9 @@ __device_noinline void svm_eval_nodes(KernelGlobals *kg, ShaderData *sd, ShaderT
 			case NODE_TEX_IMAGE:
 				svm_node_tex_image(kg, sd, stack, node);
 				break;
+			case NODE_TEX_IMAGE_BOX:
+				svm_node_tex_image_box(kg, sd, stack, node);
+				break;
 			case NODE_TEX_ENVIRONMENT:
 				svm_node_tex_environment(kg, sd, stack, node);
 				break;
@@ -249,6 +253,9 @@ __device_noinline void svm_eval_nodes(KernelGlobals *kg, ShaderData *sd, ShaderT
 			case NODE_TEX_CHECKER:
 				svm_node_tex_checker(kg, sd, stack, node, &offset);
 				break;
+			case NODE_TEX_BRICK:
+				svm_node_tex_brick(kg, sd, stack, node, &offset);
+				break;
 #endif
 			case NODE_CAMERA:
 				svm_node_camera(kg, sd, stack, node.y, node.z, node.w);
diff --git a/intern/cycles/kernel/svm/svm_brick.h b/intern/cycles/kernel/svm/svm_brick.h
new file mode 100644
index 00000000000..50de19b825d
--- /dev/null
+++ b/intern/cycles/kernel/svm/svm_brick.h
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2012, Blender Foundation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+CCL_NAMESPACE_BEGIN
+
+/* Brick */
+
+__device_noinline float brick_noise(int n) /* fast integer noise */
+{
+	int nn;
+	n = (n >> 13) ^ n;
+	nn = (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff;
+	return 0.5f * ((float)nn / 1073741824.0f);
+}
+
+__device_noinline float svm_brick(float3 p, float scale, float mortar_size, float bias,
+	float brick_width, float row_height, float offset_amount, int offset_frequency,
+	float squash_amount, int squash_frequency, float *tint)
+{	
+	p *= scale;
+
+	int bricknum, rownum;
+	float offset = 0.0f;
+	float x, y;
+
+	rownum = (int)floor(p.y / row_height);
+	
+	if(offset_frequency && squash_frequency) {
+		brick_width *= ((int)(rownum) % squash_frequency ) ? 1.0f : squash_amount; /* squash */
+		offset = ((int)(rownum) % offset_frequency ) ? 0 : (brick_width*offset_amount); /* offset */
+	}
+
+	bricknum = (int)floor((p.x+offset) / brick_width);
+
+	x = (p.x+offset) - brick_width*bricknum;
+	y = p.y - row_height*rownum;
+
+	*tint = clamp((brick_noise((rownum << 16) + (bricknum & 0xFFFF)) + bias), 0.0f, 1.0f);
+
+	return (x < mortar_size || y < mortar_size ||
+		x > (brick_width - mortar_size) ||
+		y > (row_height - mortar_size)) ? 1.0f : 0.0f;
+}
+
+__device void svm_node_tex_brick(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node, int *offset)
+{	
+	uint4 node2 = read_node(kg, offset);
+	uint4 node3 = read_node(kg, offset);
+	
+	/* Input and Output Sockets */
+	uint co_offset, color1_offset, color2_offset, mortar_offset, scale_offset;
+	uint mortar_size_offset, bias_offset, brick_width_offset, row_height_offset;
+	uint color_offset, fac_offset;
+	
+	/* RNA properties */
+	uint offset_frequency, squash_frequency;
+	
+	float tint = 0;
+
+	decode_node_uchar4(node.y, &co_offset, &color1_offset, &color2_offset, &mortar_offset);
+	decode_node_uchar4(node.z, &scale_offset, &mortar_size_offset, &bias_offset, &brick_width_offset);
+	decode_node_uchar4(node.w, &row_height_offset, &color_offset, &fac_offset, NULL);
+	
+	decode_node_uchar4(node2.x, &offset_frequency, &squash_frequency, NULL, NULL);
+
+	float3 co = stack_load_float3(stack, co_offset);
+	
+	float3 color1 = stack_load_float3(stack, color1_offset);
+	float3 color2 = stack_load_float3(stack, color2_offset);
+	float3 mortar = stack_load_float3(stack, mortar_offset);
+	
+	float scale = stack_load_float_default(stack, scale_offset, node2.y);
+	float mortar_size = stack_load_float_default(stack, mortar_size_offset, node2.z);
+	float bias = stack_load_float_default(stack, bias_offset, node2.w);
+	float brick_width = stack_load_float_default(stack, brick_width_offset, node3.x);
+	float row_height = stack_load_float_default(stack, row_height_offset, node3.y);
+	float offset_amount = __int_as_float(node3.z);
+	float squash_amount = __int_as_float(node3.w);
+	
+	float f = svm_brick(co, scale, mortar_size, bias, brick_width, row_height,
+		offset_amount, offset_frequency, squash_amount, squash_frequency,
+		&tint);
+	
+	if(f != 1.0f) {
+		float facm = 1.0f - tint;
+
+		color1.x = facm * (color1.x) + tint * color2.x;
+		color1.y = facm * (color1.y) + tint * color2.y;
+		color1.z = facm * (color1.z) + tint * color2.z;
+	}
+
+	if(stack_valid(color_offset))
+		stack_store_float3(stack, color_offset, (f == 1.0f)? mortar: color1);
+	if(stack_valid(fac_offset))
+		stack_store_float(stack, fac_offset, f);
+}
+
+CCL_NAMESPACE_END
+
diff --git a/intern/cycles/kernel/svm/svm_image.h b/intern/cycles/kernel/svm/svm_image.h
index 3b2b9204d86..662419418e3 100644
--- a/intern/cycles/kernel/svm/svm_image.h
+++ b/intern/cycles/kernel/svm/svm_image.h
@@ -50,7 +50,7 @@ __device_inline float svm_image_texture_frac(float x, int *ix)
 	return x - (float)i;
 }
 
-__device float4 svm_image_texture(KernelGlobals *kg, int id, float x, float y)
+__device float4 svm_image_texture(KernelGlobals *kg, int id, float x, float y, uint srgb)
 {
 	uint4 info = kernel_tex_fetch(__tex_image_packed_info, id);
 	uint width = info.x;
@@ -82,15 +82,24 @@ __device float4 svm_image_texture(KernelGlobals *kg, int id, float x, float y)
 	r += ty*(1.0f - tx)*svm_image_texture_read(kg, offset + ix + niy*width);
 	r += ty*tx*svm_image_texture_read(kg, offset + nix + niy*width);
 
+	if(srgb) {
+		r.x = color_srgb_to_scene_linear(r.x);
+		r.y = color_srgb_to_scene_linear(r.y);
+		r.z = color_srgb_to_scene_linear(r.z);
+	}
+
 	return r;
 }
 
 #else
 
-__device float4 svm_image_texture(KernelGlobals *kg, int id, float x, float y)
+__device float4 svm_image_texture(KernelGlobals *kg, int id, float x, float y, uint srgb)
 {
 	float4 r;
 
+#ifdef __KERNEL_CPU__
+	r = kernel_tex_image_interp(id, x, y);
+#else
 	/* not particularly proud of this massive switch, what are the
 	 * alternatives?
 	 * - use a single big 1D texture, and do our own lookup/filtering
@@ -101,11 +110,11 @@ __device float4 svm_image_texture(KernelGlobals *kg, int id, float x, float y)
 	 * we still need some for other storage */
 
 	switch(id) {
-		case 0: r = kernel_tex_image_interp(__tex_image_000, x, y); break;
-		case 1: r = kernel_tex_image_interp(__tex_image_001, x, y); break;
-		case 2: r = kernel_tex_image_interp(__tex_image_002, x, y); break;
-		case 3: r = kernel_tex_image_interp(__tex_image_003, x, y); break;
-		case 4: r = kernel_tex_image_interp(__tex_image_004, x, y); break;
+		case 0: r = kernel_tex_image_interp(__tex_image_float_000, x, y); break;
+		case 1: r = kernel_tex_image_interp(__tex_image_float_001, x, y); break;
+		case 2: r = kernel_tex_image_interp(__tex_image_float_002, x, y); break;
+		case 3: r = kernel_tex_image_interp(__tex_image_float_003, x, y); break;
+		case 4: r = kernel_tex_image_interp(__tex_image_float_004, x, y); break;
 		case 5: r = kernel_tex_image_interp(__tex_image_005, x, y); break;
 		case 6: r = kernel_tex_image_interp(__tex_image_006, x, y); break;
 		case 7: r = kernel_tex_image_interp(__tex_image_007, x, y); break;
@@ -196,15 +205,22 @@ __device float4 svm_image_texture(KernelGlobals *kg, int id, float x, float y)
 		case 92: r = kernel_tex_image_interp(__tex_image_092, x, y); break;
 		case 93: r = kernel_tex_image_interp(__tex_image_093, x, y); break;
 		case 94: r = kernel_tex_image_interp(__tex_image_094, x, y); break;
-		case 95: r = kernel_tex_image_interp(__tex_image_float_095, x, y); break;
-		case 96: r = kernel_tex_image_interp(__tex_image_float_096, x, y); break;
-		case 97: r = kernel_tex_image_interp(__tex_image_float_097, x, y); break;
-		case 98: r = kernel_tex_image_interp(__tex_image_float_098, x, y); break;
-		case 99: r = kernel_tex_image_interp(__tex_image_float_099, x, y); break;
+		case 95: r = kernel_tex_image_interp(__tex_image_095, x, y); break;
+		case 96: r = kernel_tex_image_interp(__tex_image_096, x, y); break;
+		case 97: r = kernel_tex_image_interp(__tex_image_097, x, y); break;
+		case 98: r = kernel_tex_image_interp(__tex_image_098, x, y); break;
+		case 99: r = kernel_tex_image_interp(__tex_image_099, x, y); break;
 		default: 
 			kernel_assert(0);
 			return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
 	}
+#endif
+
+	if(srgb) {
+		r.x = color_srgb_to_scene_linear(r.x);
+		r.y = color_srgb_to_scene_linear(r.y);
+		r.z = color_srgb_to_scene_linear(r.z);
+	}
 
 	return r;
 }
@@ -219,21 +235,102 @@ __device void svm_node_tex_image(KernelGlobals *kg, ShaderData *sd, float *stack
 	decode_node_uchar4(node.z, &co_offset, &out_offset, &alpha_offset, &srgb);
 
 	float3 co = stack_load_float3(stack, co_offset);
-	float4 f = svm_image_texture(kg, id, co.x, co.y);
-	float3 r = make_float3(f.x, f.y, f.z);
+	float4 f = svm_image_texture(kg, id, co.x, co.y, srgb);
 
-	if(srgb) {
-		r.x = color_srgb_to_scene_linear(r.x);
-		r.y = color_srgb_to_scene_linear(r.y);
-		r.z = color_srgb_to_scene_linear(r.z);
+	if(stack_valid(out_offset))
+		stack_store_float3(stack, out_offset, make_float3(f.x, f.y, f.z));
+	if(stack_valid(alpha_offset))
+		stack_store_float(stack, alpha_offset, f.w);
+}
+
+__device void svm_node_tex_image_box(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node)
+{
+	/* get object space normal */
+	float3 N = sd->N;
+
+	N = sd->N;
+	if(sd->object != ~0)
+		object_inverse_normal_transform(kg, sd, &N);
+
+	/* project from direction vector to barycentric coordinates in triangles */
+	N.x = fabsf(N.x);
+	N.y = fabsf(N.y);
+	N.z = fabsf(N.z);
+
+	N /= (N.x + N.y + N.z);
+
+	/* basic idea is to think of this as a triangle, each corner representing
+	 * one of the 3 faces of the cube. in the corners we have single textures,
+	 * in between we blend between two textures, and in the middle we a blend
+	 * between three textures.
+	 *
+	 * the Nxyz values are the barycentric coordinates in an equilateral
+	 * triangle, which in case of blending in the middle has a smaller
+	 * equilateral triangle where 3 textures blend. this divides things into
+	 * 7 zones, with an if() test for each zone */
+
+	float3 weight = make_float3(0.0f, 0.0f, 0.0f);
+	float blend = __int_as_float(node.w);
+	float limit = 0.5f*(1.0f + blend);
+
+	/* first test for corners with single texture */
+	if(N.x > limit*(N.x + N.y) && N.x > limit*(N.x + N.z)) {
+		weight.x = 1.0f;
+	}
+	else if(N.y > limit*(N.x + N.y) && N.y > limit*(N.y + N.z)) {
+		weight.y = 1.0f;
 	}
+	else if(N.z > limit*(N.x + N.z) && N.z > limit*(N.y + N.z)) {
+		weight.z = 1.0f;
+	}
+	else if(blend > 0.0f) {
+		/* in case of blending, test for mixes between two textures */
+		if(N.z < (1.0f - limit)*(N.y + N.x)) {
+			weight.x = N.x/(N.x + N.y);
+			weight.x = clamp((weight.x - 0.5f*(1.0f - blend))/blend, 0.0f, 1.0f);
+			weight.y = 1.0f - weight.x;
+		}
+		else if(N.x < (1.0f - limit)*(N.y + N.z)) {
+			weight.y = N.y/(N.y + N.z);
+			weight.y = clamp((weight.y - 0.5f*(1.0f - blend))/blend, 0.0f, 1.0f);
+			weight.z = 1.0f - weight.y;
+		}
+		else if(N.y < (1.0f - limit)*(N.x + N.z)) {
+			weight.x = N.x/(N.x + N.z);
+			weight.x = clamp((weight.x - 0.5f*(1.0f - blend))/blend, 0.0f, 1.0f);
+			weight.z = 1.0f - weight.x;
+		}
+		else {
+			/* last case, we have a mix between three */
+			weight.x = ((2.0f - limit)*N.x + (limit - 1.0f))/(2.0f*limit - 1.0f);
+			weight.y = ((2.0f - limit)*N.y + (limit - 1.0f))/(2.0f*limit - 1.0f);
+			weight.z = ((2.0f - limit)*N.z + (limit - 1.0f))/(2.0f*limit - 1.0f);
+		}
+	}
+
+	/* now fetch textures */
+	uint co_offset, out_offset, alpha_offset, srgb;
+	decode_node_uchar4(node.z, &co_offset, &out_offset, &alpha_offset, &srgb);
+
+	float3 co = stack_load_float3(stack, co_offset);
+	uint id = node.y;
+
+	float4 f = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+
+	if(weight.x > 0.0f)
+		f += weight.x*svm_image_texture(kg, id, co.y, co.z, srgb);
+	if(weight.y > 0.0f)
+		f += weight.y*svm_image_texture(kg, id, co.x, co.z, srgb);
+	if(weight.z > 0.0f)
+		f += weight.z*svm_image_texture(kg, id, co.y, co.x, srgb);
 
 	if(stack_valid(out_offset))
-		stack_store_float3(stack, out_offset, r);
+		stack_store_float3(stack, out_offset, make_float3(f.x, f.y, f.z));
 	if(stack_valid(alpha_offset))
 		stack_store_float(stack, alpha_offset, f.w);
 }
 
+
 __device void svm_node_tex_environment(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node)
 {
 	uint id = node.y;
@@ -252,17 +349,10 @@ __device void svm_node_tex_environment(KernelGlobals *kg, ShaderData *sd, float
 	else
 		uv = direction_to_mirrorball(co);
 
-	float4 f = svm_image_texture(kg, id, uv.x, uv.y);
-	float3 r = make_float3(f.x, f.y, f.z);
-
-	if(srgb) {
-		r.x = color_srgb_to_scene_linear(r.x);
-		r.y = color_srgb_to_scene_linear(r.y);
-		r.z = color_srgb_to_scene_linear(r.z);
-	}
+	float4 f = svm_image_texture(kg, id, uv.x, uv.y, srgb);
 
 	if(stack_valid(out_offset))
-		stack_store_float3(stack, out_offset, r);
+		stack_store_float3(stack, out_offset, make_float3(f.x, f.y, f.z));
 	if(stack_valid(alpha_offset))
 		stack_store_float(stack, alpha_offset, f.w);
 }
diff --git a/intern/cycles/kernel/svm/svm_types.h b/intern/cycles/kernel/svm/svm_types.h
index 16c726e7faa..c82eafc790a 100644
--- a/intern/cycles/kernel/svm/svm_types.h
+++ b/intern/cycles/kernel/svm/svm_types.h
@@ -40,6 +40,7 @@ typedef enum NodeType {
 	NODE_MIX_CLOSURE,
 	NODE_JUMP,
 	NODE_TEX_IMAGE,
+	NODE_TEX_IMAGE_BOX,
 	NODE_TEX_SKY,
 	NODE_GEOMETRY,
 	NODE_LIGHT_PATH,
@@ -89,7 +90,8 @@ typedef enum NodeType {
 	NODE_MIN_MAX,
 	NODE_LIGHT_FALLOFF,
 	NODE_OBJECT_INFO,
-	NODE_PARTICLE_INFO
+	NODE_PARTICLE_INFO,
+	NODE_TEX_BRICK
 } NodeType;
 
 typedef enum NodeAttributeType {