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.

12 files changed, 258 insertions, 120 deletions

diff --git a/intern/cycles/blender/addon/properties.py b/intern/cycles/blender/addon/properties.py
index 7a22cba316e..7f3eca471e6 100644
--- a/intern/cycles/blender/addon/properties.py
+++ b/intern/cycles/blender/addon/properties.py
@@ -241,12 +241,14 @@ class CyclesRenderSettings(bpy.types.PropertyGroup):
                 min=1, max=4096,
                 default=1024,
                 )
-        cls.debug_min_size = IntProperty(
-                name="Min Size",
-                description="",
-                min=1, max=4096,
-                default=64,
+
+        cls.resolution_divider = IntProperty(
+                name="Resolution Divider",
+                description="For viewport render, the number of lower resolutions to render before the full resolution",
+                min=1, max=512,
+                default=4,
                 )
+
         cls.debug_reset_timeout = FloatProperty(
                 name="Reset timeout",
                 description="",
diff --git a/intern/cycles/blender/addon/ui.py b/intern/cycles/blender/addon/ui.py
index c30581ecd40..bf44a558b1a 100644
--- a/intern/cycles/blender/addon/ui.py
+++ b/intern/cycles/blender/addon/ui.py
@@ -197,8 +197,13 @@ class CyclesRender_PT_performance(CyclesButtonsPanel, Panel):
 
         sub = col.column(align=True)
         sub.label(text="Tiles:")
-        sub.prop(cscene, "debug_tile_size")
-        sub.prop(cscene, "debug_min_size")
+
+        sub.prop(rd, "parts_x", text="X")
+        sub.prop(rd, "parts_y", text="Y")
+
+        subsub = sub.column()
+        subsub.enabled = not rd.use_border
+        subsub.prop(rd, "use_save_buffers")
 
         col = split.column()
 
@@ -208,6 +213,10 @@ class CyclesRender_PT_performance(CyclesButtonsPanel, Panel):
         sub.prop(cscene, "debug_use_spatial_splits")
         sub.prop(cscene, "use_cache")
 
+        sub = col.column(align=True)
+        sub.label(text="Viewport:")
+        sub.prop(cscene, "resolution_divider")
+
 
 class CyclesRender_PT_layers(CyclesButtonsPanel, Panel):
     bl_label = "Layers"
diff --git a/intern/cycles/blender/blender_mesh.cpp b/intern/cycles/blender/blender_mesh.cpp
index 16e4ceded89..9764f24a893 100644
--- a/intern/cycles/blender/blender_mesh.cpp
+++ b/intern/cycles/blender/blender_mesh.cpp
@@ -317,11 +317,11 @@ void BlenderSync::sync_mesh_motion(BL::Object b_ob, Mesh *mesh, int motion)
 		BL::Mesh::vertices_iterator v;
 		AttributeStandard std = (motion == -1)? ATTR_STD_MOTION_PRE: ATTR_STD_MOTION_POST;
 		Attribute *attr_M = mesh->attributes.add(std);
-		float3 *M = attr_M->data_float3();
+		float3 *M = attr_M->data_float3(), *cur_M;
 		size_t i = 0;
 
-		for(b_mesh.vertices.begin(v); v != b_mesh.vertices.end() && i < size; ++v, M++, i++)
-			*M = get_float3(v->co());
+		for(b_mesh.vertices.begin(v), cur_M = M; v != b_mesh.vertices.end() && i < size; ++v, cur_M++, i++)
+			*cur_M = get_float3(v->co());
 
 		/* if number of vertices changed, or if coordinates stayed the same, drop it */
 		if(i != size || memcmp(M, &mesh->verts[0], sizeof(float3)*size) == 0)
diff --git a/intern/cycles/blender/blender_object.cpp b/intern/cycles/blender/blender_object.cpp
index 55291639ae1..eb9deb0de2d 100644
--- a/intern/cycles/blender/blender_object.cpp
+++ b/intern/cycles/blender/blender_object.cpp
@@ -300,14 +300,16 @@ void BlenderSync::sync_objects(BL::SpaceView3D b_v3d, int motion)
 	BL::Scene b_sce = b_scene;
 	int particle_offset = 1;	/* first particle is dummy for regular, non-instanced objects */
 
-	for(; b_sce; b_sce = b_sce.background_set()) {
-		for(b_sce.objects.begin(b_ob); b_ob != b_sce.objects.end(); ++b_ob) {
+	bool cancel = false;
+
+	for(; b_sce && !cancel; b_sce = b_sce.background_set()) {
+		for(b_sce.objects.begin(b_ob); b_ob != b_sce.objects.end() && !cancel; ++b_ob) {
 			bool hide = (render_layer.use_viewport_visibility)? b_ob->hide(): b_ob->hide_render();
-			uint ob_layer = get_layer(b_ob->layers(), b_ob->layers_local_view(), object_is_light(*b_ob));
-			CYCLES_LOCAL_LAYER_HACK(render_layer.use_localview, ob_layer);
+			uint ob_layer = get_layer(b_ob->layers(), b_ob->layers_local_view(), render_layer.use_localview, object_is_light(*b_ob));
 			hide = hide || !(ob_layer & scene_layer);
 
 			if(!hide) {
+				progress.set_status("Synchronizing object", (*b_ob).name());
 
 				int num_particles = object_count_particles(*b_ob);
 
@@ -349,10 +351,12 @@ void BlenderSync::sync_objects(BL::SpaceView3D b_v3d, int motion)
 
 				particle_offset += num_particles;
 			}
+
+			cancel = progress.get_cancel();
 		}
 	}
 
-	if(!motion) {
+	if(!cancel && !motion) {
 		sync_background_light();
 
 		/* handle removed data and modified pointers */
diff --git a/intern/cycles/blender/blender_particles.cpp b/intern/cycles/blender/blender_particles.cpp
index 177912cd8f0..f309960fc55 100644
--- a/intern/cycles/blender/blender_particles.cpp
+++ b/intern/cycles/blender/blender_particles.cpp
@@ -199,8 +199,7 @@ void BlenderSync::sync_particle_systems()
 	for(; b_sce; b_sce = b_sce.background_set()) {
 		for(b_sce.objects.begin(b_ob); b_ob != b_sce.objects.end(); ++b_ob) {
 			bool hide = (render_layer.use_viewport_visibility)? b_ob->hide(): b_ob->hide_render();
-			uint ob_layer = get_layer(b_ob->layers(), b_ob->layers_local_view(), object_is_light(*b_ob));
-			CYCLES_LOCAL_LAYER_HACK(render_layer.use_localview, ob_layer);
+			uint ob_layer = get_layer(b_ob->layers(), b_ob->layers_local_view(), render_layer.use_localview, object_is_light(*b_ob));
 			hide = hide || !(ob_layer & scene_layer);
 
 			if(!hide) {
diff --git a/intern/cycles/blender/blender_python.cpp b/intern/cycles/blender/blender_python.cpp
index 4560c2f8543..96d5bb61ff8 100644
--- a/intern/cycles/blender/blender_python.cpp
+++ b/intern/cycles/blender/blender_python.cpp
@@ -80,6 +80,8 @@ static PyObject *create_func(PyObject *self, PyObject *args)
 	/* create session */
 	BlenderSession *session;
 
+	Py_BEGIN_ALLOW_THREADS
+
 	if(rv3d) {
 		/* interactive session */
 		int width = region.width();
@@ -91,7 +93,9 @@ static PyObject *create_func(PyObject *self, PyObject *args)
 		/* offline session */
 		session = new BlenderSession(engine, userpref, data, scene);
 	}
-	
+
+	Py_END_ALLOW_THREADS
+
 	return PyLong_FromVoidPtr(session);
 }
 
@@ -136,9 +140,13 @@ static PyObject *draw_func(PyObject *self, PyObject *args)
 
 static PyObject *sync_func(PyObject *self, PyObject *value)
 {
+	Py_BEGIN_ALLOW_THREADS
+
 	BlenderSession *session = (BlenderSession*)PyLong_AsVoidPtr(value);
 	session->synchronize();
 
+	Py_END_ALLOW_THREADS
+
 	Py_RETURN_NONE;
 }
 
diff --git a/intern/cycles/blender/blender_session.cpp b/intern/cycles/blender/blender_session.cpp
index d09e43bd76d..7b80c520e72 100644
--- a/intern/cycles/blender/blender_session.cpp
+++ b/intern/cycles/blender/blender_session.cpp
@@ -42,14 +42,13 @@ CCL_NAMESPACE_BEGIN
 BlenderSession::BlenderSession(BL::RenderEngine b_engine_, BL::UserPreferences b_userpref_,
 	BL::BlendData b_data_, BL::Scene b_scene_)
 : b_engine(b_engine_), b_userpref(b_userpref_), b_data(b_data_), b_scene(b_scene_),
-  b_v3d(PointerRNA_NULL), b_rv3d(PointerRNA_NULL),
-  b_rr(PointerRNA_NULL), b_rlay(PointerRNA_NULL)
+  b_v3d(PointerRNA_NULL), b_rv3d(PointerRNA_NULL)
 {
 	/* offline render */
-	BL::RenderSettings r = b_scene.render();
 
-	width = (int)(r.resolution_x()*r.resolution_percentage()/100);
-	height = (int)(r.resolution_y()*r.resolution_percentage()/100);
+	width = b_engine.resolution_x();
+	height = b_engine.resolution_y();
+
 	background = true;
 	last_redraw_time = 0.0f;
 
@@ -60,7 +59,7 @@ BlenderSession::BlenderSession(BL::RenderEngine b_engine_, BL::UserPreferences b
 	BL::BlendData b_data_, BL::Scene b_scene_,
 	BL::SpaceView3D b_v3d_, BL::RegionView3D b_rv3d_, int width_, int height_)
 : b_engine(b_engine_), b_userpref(b_userpref_), b_data(b_data_), b_scene(b_scene_),
-  b_v3d(b_v3d_), b_rv3d(b_rv3d_), b_rr(PointerRNA_NULL), b_rlay(PointerRNA_NULL)
+  b_v3d(b_v3d_), b_rv3d(b_rv3d_)
 {
 	/* 3d view render */
 	width = width_;
@@ -80,17 +79,24 @@ BlenderSession::~BlenderSession()
 void BlenderSession::create_session()
 {
 	SceneParams scene_params = BlenderSync::get_scene_params(b_scene, background);
-	SessionParams session_params = BlenderSync::get_session_params(b_userpref, b_scene, background);
+	SessionParams session_params = BlenderSync::get_session_params(b_engine, b_userpref, b_scene, background);
 
 	/* reset status/progress */
 	last_status = "";
 	last_progress = -1.0f;
 
 	/* create scene */
-	scene = new Scene(scene_params);
+	scene = new Scene(scene_params, session_params.device);
+
+	/* create session */
+	session = new Session(session_params);
+	session->scene = scene;
+	session->progress.set_update_callback(function_bind(&BlenderSession::tag_redraw, this));
+	session->progress.set_cancel_callback(function_bind(&BlenderSession::test_cancel, this));
+	session->set_pause(BlenderSync::get_session_pause(b_scene, background));
 
 	/* create sync */
-	sync = new BlenderSync(b_data, b_scene, scene, !background);
+	sync = new BlenderSync(b_engine, b_data, b_scene, scene, !background, session->progress);
 	sync->sync_data(b_v3d, b_engine.camera_override());
 
 	if(b_rv3d)
@@ -98,13 +104,6 @@ void BlenderSession::create_session()
 	else
 		sync->sync_camera(b_engine.camera_override(), width, height);
 
-	/* create session */
-	session = new Session(session_params);
-	session->scene = scene;
-	session->progress.set_update_callback(function_bind(&BlenderSession::tag_redraw, this));
-	session->progress.set_cancel_callback(function_bind(&BlenderSession::test_cancel, this));
-	session->set_pause(BlenderSync::get_session_pause(b_scene, background));
-
 	/* set buffer parameters */
 	BufferParams buffer_params = BlenderSync::get_buffer_params(b_scene, scene->camera, width, height);
 	session->reset(buffer_params, session_params.samples);
@@ -177,35 +176,100 @@ static PassType get_pass_type(BL::RenderPass b_pass)
 	return PASS_NONE;
 }
 
+static BL::RenderResult begin_render_result(BL::RenderEngine b_engine, int x, int y, int w, int h, const char *layername)
+{
+	RenderResult *rrp = RE_engine_begin_result((RenderEngine*)b_engine.ptr.data, x, y, w, h, layername);
+	PointerRNA rrptr;
+	RNA_pointer_create(NULL, &RNA_RenderResult, rrp, &rrptr);
+	return BL::RenderResult(rrptr);
+}
+
+static void end_render_result(BL::RenderEngine b_engine, BL::RenderResult b_rr, bool cancel = false)
+{
+	RE_engine_end_result((RenderEngine*)b_engine.ptr.data, (RenderResult*)b_rr.ptr.data, (int)cancel);
+}
+
+void BlenderSession::do_write_update_render_tile(RenderTile& rtile, bool do_update_only)
+{
+	BufferParams& params = rtile.buffers->params;
+	int x = params.full_x - session->tile_manager.params.full_x;
+	int y = params.full_y - session->tile_manager.params.full_y;
+	int w = params.width;
+	int h = params.height;
+
+	/* get render result */
+	BL::RenderResult b_rr = begin_render_result(b_engine, x, y, w, h, b_rlay_name.c_str());
+
+	/* can happen if the intersected rectangle gives 0 width or height */
+	if (b_rr.ptr.data == NULL) {
+		return;
+	}
+
+	BL::RenderResult::layers_iterator b_single_rlay;
+	b_rr.layers.begin(b_single_rlay);
+	BL::RenderLayer b_rlay = *b_single_rlay;
+
+	if (do_update_only) {
+		/* update only needed */
+		update_render_result(b_rr, b_rlay, rtile);
+		end_render_result(b_engine, b_rr, true);
+	}
+	else {
+		/* write result */
+		write_render_result(b_rr, b_rlay, rtile);
+		end_render_result(b_engine, b_rr);
+	}
+}
+
+void BlenderSession::write_render_tile(RenderTile& rtile)
+{
+	do_write_update_render_tile(rtile, false);
+}
+
+void BlenderSession::update_render_tile(RenderTile& rtile)
+{
+	do_write_update_render_tile(rtile, true);
+}
+
 void BlenderSession::render()
 {
+	/* set callback to write out render results */
+	session->write_render_tile_cb = function_bind(&BlenderSession::write_render_tile, this, _1);
+	session->update_render_tile_cb = function_bind(&BlenderSession::update_render_tile, this, _1);
+
 	/* get buffer parameters */
-	SessionParams session_params = BlenderSync::get_session_params(b_userpref, b_scene, background);
+	SessionParams session_params = BlenderSync::get_session_params(b_engine, b_userpref, b_scene, background);
 	BufferParams buffer_params = BlenderSync::get_buffer_params(b_scene, scene->camera, width, height);
-	int w = buffer_params.width, h = buffer_params.height;
-
-	/* create render result */
-	RenderResult *rrp = RE_engine_begin_result((RenderEngine*)b_engine.ptr.data, 0, 0, w, h);
-	PointerRNA rrptr;
-	RNA_pointer_create(NULL, &RNA_RenderResult, rrp, &rrptr);
-	b_rr = BL::RenderResult(rrptr);
 
+	/* render each layer */
 	BL::RenderSettings r = b_scene.render();
-	BL::RenderResult::layers_iterator b_iter;
-	BL::RenderLayers b_rr_layers(r.ptr);
+	BL::RenderSettings::layers_iterator b_iter;
 	
-	/* render each layer */
-	for(b_rr.layers.begin(b_iter); b_iter != b_rr.layers.end(); ++b_iter) {
-		/* set layer */
-		b_rlay = *b_iter;
+	for(r.layers.begin(b_iter); b_iter != r.layers.end(); ++b_iter) {
+		b_rlay_name = b_iter->name();
+
+		/* temporary render result to find needed passes */
+		BL::RenderResult b_rr = begin_render_result(b_engine, 0, 0, 1, 1, b_rlay_name.c_str());
+		BL::RenderResult::layers_iterator b_single_rlay;
+		b_rr.layers.begin(b_single_rlay);
+
+		/* layer will be missing if it was disabled in the UI */
+		if(b_single_rlay == b_rr.layers.end()) {
+			end_render_result(b_engine, b_rr, true);
+			continue;
+		}
+
+		BL::RenderLayer b_rlay = *b_single_rlay;
 
 		/* add passes */
 		vector<Pass> passes;
 		Pass::add(PASS_COMBINED, passes);
 
 		if(session_params.device.advanced_shading) {
+
+			/* loop over passes */
 			BL::RenderLayer::passes_iterator b_pass_iter;
-			
+
 			for(b_rlay.passes.begin(b_pass_iter); b_pass_iter != b_rlay.passes.end(); ++b_pass_iter) {
 				BL::RenderPass b_pass(*b_pass_iter);
 				PassType pass_type = get_pass_type(b_pass);
@@ -217,13 +281,16 @@ void BlenderSession::render()
 			}
 		}
 
+		/* free result without merging */
+		end_render_result(b_engine, b_rr, true);
+
 		buffer_params.passes = passes;
 		scene->film->tag_passes_update(scene, passes);
 		scene->film->tag_update(scene);
 		scene->integrator->tag_update(scene);
 
 		/* update scene */
-		sync->sync_data(b_v3d, b_engine.camera_override(), b_iter->name().c_str());
+		sync->sync_data(b_v3d, b_engine.camera_override(), b_rlay_name.c_str());
 
 		/* update session */
 		int samples = sync->get_layer_samples();
@@ -235,19 +302,16 @@ void BlenderSession::render()
 
 		if(session->progress.get_cancel())
 			break;
-
-		/* write result */
-		write_render_result();
 	}
 
-	/* delete render result */
-	RE_engine_end_result((RenderEngine*)b_engine.ptr.data, (RenderResult*)b_rr.ptr.data);
+	/* clear callback */
+	session->write_render_tile_cb = NULL;
+	session->update_render_tile_cb = NULL;
 }
 
-void BlenderSession::write_render_result()
+void BlenderSession::do_write_update_render_result(BL::RenderResult b_rr, BL::RenderLayer b_rlay, RenderTile& rtile, bool do_update_only)
 {
-	/* get state */
-	RenderBuffers *buffers = session->buffers;
+	RenderBuffers *buffers = rtile.buffers;
 
 	/* copy data from device */
 	if(!buffers->copy_from_device())
@@ -255,41 +319,49 @@ void BlenderSession::write_render_result()
 
 	BufferParams& params = buffers->params;
 	float exposure = scene->film->exposure;
-	double total_time, sample_time;
-	int sample;
-
-	session->progress.get_sample(sample, total_time, sample_time);
 
 	vector<float> pixels(params.width*params.height*4);
 
-	/* copy each pass */
-	BL::RenderLayer::passes_iterator b_iter;
-	
-	for(b_rlay.passes.begin(b_iter); b_iter != b_rlay.passes.end(); ++b_iter) {
-		BL::RenderPass b_pass(*b_iter);
+	if (!do_update_only) {
+		/* copy each pass */
+		BL::RenderLayer::passes_iterator b_iter;
+
+		for(b_rlay.passes.begin(b_iter); b_iter != b_rlay.passes.end(); ++b_iter) {
+			BL::RenderPass b_pass(*b_iter);
 
-		/* find matching pass type */
-		PassType pass_type = get_pass_type(b_pass);
-		int components = b_pass.channels();
+			/* find matching pass type */
+			PassType pass_type = get_pass_type(b_pass);
+			int components = b_pass.channels();
 
-		/* copy pixels */
-		if(buffers->get_pass(pass_type, exposure, sample, components, &pixels[0]))
-			rna_RenderPass_rect_set(&b_pass.ptr, &pixels[0]);
+			/* copy pixels */
+			if(buffers->get_pass_rect(pass_type, exposure, rtile.sample, components, &pixels[0]))
+				rna_RenderPass_rect_set(&b_pass.ptr, &pixels[0]);
+		}
 	}
 
 	/* copy combined pass */
-	if(buffers->get_pass(PASS_COMBINED, exposure, sample, 4, &pixels[0]))
+	if(buffers->get_pass_rect(PASS_COMBINED, exposure, rtile.sample, 4, &pixels[0]))
 		rna_RenderLayer_rect_set(&b_rlay.ptr, &pixels[0]);
 
 	/* tag result as updated */
 	RE_engine_update_result((RenderEngine*)b_engine.ptr.data, (RenderResult*)b_rr.ptr.data);
 }
 
+void BlenderSession::write_render_result(BL::RenderResult b_rr, BL::RenderLayer b_rlay, RenderTile& rtile)
+{
+	do_write_update_render_result(b_rr, b_rlay, rtile, false);
+}
+
+void BlenderSession::update_render_result(BL::RenderResult b_rr, BL::RenderLayer b_rlay, RenderTile& rtile)
+{
+	do_write_update_render_result(b_rr, b_rlay, rtile, true);
+}
+
 void BlenderSession::synchronize()
 {
 	/* on session/scene parameter changes, we recreate session entirely */
 	SceneParams scene_params = BlenderSync::get_scene_params(b_scene, background);
-	SessionParams session_params = BlenderSync::get_session_params(b_userpref, b_scene, background);
+	SessionParams session_params = BlenderSync::get_session_params(b_engine, b_userpref, b_scene, background);
 
 	if(session->params.modified(session_params) ||
 	   scene->params.modified(scene_params))
@@ -364,7 +436,7 @@ bool BlenderSession::draw(int w, int h)
 
 		/* reset if requested */
 		if(reset) {
-			SessionParams session_params = BlenderSync::get_session_params(b_userpref, b_scene, background);
+			SessionParams session_params = BlenderSync::get_session_params(b_engine, b_userpref, b_scene, background);
 			BufferParams buffer_params = BlenderSync::get_buffer_params(b_scene, scene->camera, w, h);
 
 			session->reset(buffer_params, session_params.samples);
@@ -387,11 +459,16 @@ void BlenderSession::get_status(string& status, string& substatus)
 
 void BlenderSession::get_progress(float& progress, double& total_time)
 {
-	double sample_time;
-	int sample;
+	double tile_time;
+	int tile, sample, samples_per_tile;
+	int tile_total = session->tile_manager.state.num_tiles;
+
+	session->progress.get_tile(tile, total_time, tile_time);
 
-	session->progress.get_sample(sample, total_time, sample_time);
-	progress = ((float)sample/(float)session->params.samples);
+	sample = session->progress.get_sample();
+	samples_per_tile = session->tile_manager.state.num_samples;
+
+	progress = ((float)sample/(float)(tile_total * samples_per_tile));
 }
 
 void BlenderSession::update_status_progress()
@@ -404,8 +481,13 @@ void BlenderSession::update_status_progress()
 	get_status(status, substatus);
 	get_progress(progress, total_time);
 
+	timestatus = b_scene.name();
+	if(b_rlay_name != "")
+		timestatus += ", "  + b_rlay_name;
+	timestatus += " | ";
+
 	BLI_timestr(total_time, time_str);
-	timestatus = "Elapsed: " + string(time_str) + " | ";
+	timestatus += "Elapsed: " + string(time_str) + " | ";
 
 	if(substatus.size() > 0)
 		status += " | " + substatus;
@@ -435,7 +517,6 @@ void BlenderSession::tag_redraw()
 
 		/* offline render, redraw if timeout passed */
 		if(time_dt() - last_redraw_time > 1.0) {
-			write_render_result();
 			engine_tag_redraw((RenderEngine*)b_engine.ptr.data);
 			last_redraw_time = time_dt();
 		}
diff --git a/intern/cycles/blender/blender_session.h b/intern/cycles/blender/blender_session.h
index b98e3ffed54..d52e0103bbf 100644
--- a/intern/cycles/blender/blender_session.h
+++ b/intern/cycles/blender/blender_session.h
@@ -29,6 +29,8 @@ CCL_NAMESPACE_BEGIN
 
 class Scene;
 class Session;
+class RenderBuffers;
+class RenderTile;
 
 class BlenderSession {
 public:
@@ -46,7 +48,14 @@ public:
 
 	/* offline render */
 	void render();
-	void write_render_result();
+
+	void write_render_result(BL::RenderResult b_rr, BL::RenderLayer b_rlay, RenderTile& rtile);
+	void write_render_tile(RenderTile& rtile);
+
+	/* update functions are used to update display buffer only after sample was rendered
+	 * only needed for better visual feedback */
+	void update_render_result(BL::RenderResult b_rr, BL::RenderLayer b_rlay, RenderTile& rtile);
+	void update_render_tile(RenderTile& rtile);
 
 	/* interactive updates */
 	void synchronize();
@@ -72,13 +81,16 @@ public:
 	BL::Scene b_scene;
 	BL::SpaceView3D b_v3d;
 	BL::RegionView3D b_rv3d;
-	BL::RenderResult b_rr;
-	BL::RenderLayer b_rlay;
+	string b_rlay_name;
 
 	string last_status;
 	float last_progress;
 
 	int width, height;
+
+protected:
+	void do_write_update_render_result(BL::RenderResult b_rr, BL::RenderLayer b_rlay, RenderTile& rtile, bool do_update_only);
+	void do_write_update_render_tile(RenderTile& rtile, bool do_update_only);
 };
 
 CCL_NAMESPACE_END
diff --git a/intern/cycles/blender/blender_shader.cpp b/intern/cycles/blender/blender_shader.cpp
index b82fee5edf0..9758d9bf92a 100644
--- a/intern/cycles/blender/blender_shader.cpp
+++ b/intern/cycles/blender/blender_shader.cpp
@@ -406,6 +406,8 @@ static ShaderNode *add_node(BL::BlendData b_data, BL::Scene b_scene, ShaderGraph
 			if(b_image)
 				image->filename = image_user_file_path(b_image_node.image_user(), b_image, b_scene.frame_current());
 			image->color_space = ImageTextureNode::color_space_enum[(int)b_image_node.color_space()];
+			image->projection = ImageTextureNode::projection_enum[(int)b_image_node.projection()];
+			image->projection_blend = b_image_node.projection_blend();
 			get_tex_mapping(&image->tex_mapping, b_image_node.texture_mapping());
 			node = image;
 			break;
@@ -461,6 +463,17 @@ static ShaderNode *add_node(BL::BlendData b_data, BL::Scene b_scene, ShaderGraph
 			node = checker;
 			break;
 		}
+		case BL::ShaderNode::type_TEX_BRICK: {
+			BL::ShaderNodeTexBrick b_brick_node(b_node);
+			BrickTextureNode *brick = new BrickTextureNode();
+			brick->offset = b_brick_node.offset();
+			brick->offset_frequency = b_brick_node.offset_frequency();
+			brick->squash = b_brick_node.squash();
+			brick->squash_frequency = b_brick_node.squash_frequency();
+			get_tex_mapping(&brick->tex_mapping, b_brick_node.texture_mapping());
+			node = brick;
+			break;
+		}
 		case BL::ShaderNode::type_TEX_NOISE: {
 			BL::ShaderNodeTexNoise b_noise_node(b_node);
 			NoiseTextureNode *noise = new NoiseTextureNode();
diff --git a/intern/cycles/blender/blender_sync.cpp b/intern/cycles/blender/blender_sync.cpp
index 6d014a91a9c..907573cf072 100644
--- a/intern/cycles/blender/blender_sync.cpp
+++ b/intern/cycles/blender/blender_sync.cpp
@@ -40,8 +40,9 @@ CCL_NAMESPACE_BEGIN
 
 /* Constructor */
 
-BlenderSync::BlenderSync(BL::BlendData b_data_, BL::Scene b_scene_, Scene *scene_, bool preview_)
-: b_data(b_data_), b_scene(b_scene_),
+BlenderSync::BlenderSync(BL::RenderEngine b_engine_, BL::BlendData b_data_, BL::Scene b_scene_, Scene *scene_, bool preview_, Progress &progress_)
+: b_engine(b_engine_),
+  b_data(b_data_), b_scene(b_scene_),
   shader_map(&scene_->shaders),
   object_map(&scene_->objects),
   mesh_map(&scene_->meshes),
@@ -49,7 +50,8 @@ BlenderSync::BlenderSync(BL::BlendData b_data_, BL::Scene b_scene_, Scene *scene
   particle_system_map(&scene_->particle_systems),
   world_map(NULL),
   world_recalc(false),
-  experimental(false)
+  experimental(false),
+  progress(progress_)
 {
 	scene = scene_;
 	preview = preview_;
@@ -229,8 +231,7 @@ void BlenderSync::sync_render_layers(BL::SpaceView3D b_v3d, const char *layer)
 		}
 		else {
 			render_layer.use_localview = (b_v3d.local_view() ? true : false);
-			render_layer.scene_layer = get_layer(b_v3d.layers(), b_v3d.layers_local_view());
-			CYCLES_LOCAL_LAYER_HACK(render_layer.use_localview, render_layer.scene_layer);
+			render_layer.scene_layer = get_layer(b_v3d.layers(), b_v3d.layers_local_view(), render_layer.use_localview);
 			render_layer.layer = render_layer.scene_layer;
 			render_layer.holdout_layer = 0;
 			render_layer.material_override = PointerRNA_NULL;
@@ -296,7 +297,7 @@ bool BlenderSync::get_session_pause(BL::Scene b_scene, bool background)
 	return (background)? false: get_boolean(cscene, "preview_pause");
 }
 
-SessionParams BlenderSync::get_session_params(BL::UserPreferences b_userpref, BL::Scene b_scene, bool background)
+SessionParams BlenderSync::get_session_params(BL::RenderEngine b_engine, BL::UserPreferences b_userpref, BL::Scene b_scene, bool background)
 {
 	SessionParams params;
 	PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
@@ -350,25 +351,39 @@ SessionParams BlenderSync::get_session_params(BL::UserPreferences b_userpref, BL
 		}
 	}
 
+	/* tiles */
+	if(params.device.type != DEVICE_CPU && !background) {
+		/* currently GPU could be much slower than CPU when using tiles,
+		 * still need to be investigated, but meanwhile make it possible
+		 * to work in viewport smoothly
+		 */
+		int debug_tile_size = get_int(cscene, "debug_tile_size");
+
+		params.tile_size = make_int2(debug_tile_size, debug_tile_size);
+	}
+	else {
+		int tile_x = b_engine.tile_x();
+		int tile_y = b_engine.tile_y();
+
+		params.tile_size = make_int2(tile_x, tile_y);
+	}
+
+	params.resolution = 1 << get_int(cscene, "resolution_divider");
+
 	/* other parameters */
 	params.threads = b_scene.render().threads();
-	params.tile_size = get_int(cscene, "debug_tile_size");
-	params.min_size = get_int(cscene, "debug_min_size");
+
 	params.cancel_timeout = get_float(cscene, "debug_cancel_timeout");
 	params.reset_timeout = get_float(cscene, "debug_reset_timeout");
 	params.text_timeout = get_float(cscene, "debug_text_timeout");
 
 	if(background) {
-		params.progressive = true;
-		params.min_size = INT_MAX;
+		params.progressive = false;
+		params.resolution = 1;
 	}
 	else
 		params.progressive = true;
 	
-	/* todo: multi device only works with single tiles now */
-	if(params.device.type == DEVICE_MULTI)
-		params.tile_size = INT_MAX;
-
 	return params;
 }
 
diff --git a/intern/cycles/blender/blender_sync.h b/intern/cycles/blender/blender_sync.h
index f3bd06b3a53..27f6b6ee4ee 100644
--- a/intern/cycles/blender/blender_sync.h
+++ b/intern/cycles/blender/blender_sync.h
@@ -49,7 +49,7 @@ class ShaderNode;
 
 class BlenderSync {
 public:
-	BlenderSync(BL::BlendData b_data, BL::Scene b_scene, Scene *scene_, bool preview_);
+	BlenderSync(BL::RenderEngine b_engine_, BL::BlendData b_data, BL::Scene b_scene, Scene *scene_, bool preview_, Progress &progress_);
 	~BlenderSync();
 
 	/* sync */
@@ -61,7 +61,7 @@ public:
 
 	/* get parameters */
 	static SceneParams get_scene_params(BL::Scene b_scene, bool background);
-	static SessionParams get_session_params(BL::UserPreferences b_userpref, BL::Scene b_scene, bool background);
+	static SessionParams get_session_params(BL::RenderEngine b_engine, BL::UserPreferences b_userpref, BL::Scene b_scene, bool background);
 	static bool get_session_pause(BL::Scene b_scene, bool background);
 	static BufferParams get_buffer_params(BL::Scene b_scene, Camera *cam, int width, int height);
 
@@ -97,6 +97,7 @@ private:
 	int object_count_particles(BL::Object b_ob);
 
 	/* variables */
+	BL::RenderEngine b_engine;
 	BL::BlendData b_data;
 	BL::Scene b_scene;
 
@@ -132,21 +133,9 @@ private:
 		bool use_localview;
 		int samples;
 	} render_layer;
-};
 
-/* we don't have spare bits for localview (normally 20-28)
- * because PATH_RAY_LAYER_SHIFT uses 20-32.
- * So - check if we have localview and if so, shift local
- * view bits down to 1-8, since this is done for the view
- * port only - it should be OK and not conflict with
- * render layers. - Campbell.
- *
- * ... as an alternative we could use uint64_t
- */
-#define CYCLES_LOCAL_LAYER_HACK(use_localview, layer)   \
-	if (use_localview) {                                \
-		layer >>= 20;                                   \
-	} (void)0
+	Progress &progress;
+};
 
 CCL_NAMESPACE_END
 
diff --git a/intern/cycles/blender/blender_util.h b/intern/cycles/blender/blender_util.h
index 2e9b201c0e2..d0fca9a9fb9 100644
--- a/intern/cycles/blender/blender_util.h
+++ b/intern/cycles/blender/blender_util.h
@@ -40,9 +40,9 @@ void rna_Object_create_duplilist(void *ob, void *reports, void *sce);
 void rna_Object_free_duplilist(void *ob, void *reports);
 void rna_RenderLayer_rect_set(PointerRNA *ptr, const float *values);
 void rna_RenderPass_rect_set(PointerRNA *ptr, const float *values);
-struct RenderResult *RE_engine_begin_result(struct RenderEngine *engine, int x, int y, int w, int h);
+struct RenderResult *RE_engine_begin_result(struct RenderEngine *engine, int x, int y, int w, int h, const char *layername);
 void RE_engine_update_result(struct RenderEngine *engine, struct RenderResult *result);
-void RE_engine_end_result(struct RenderEngine *engine, struct RenderResult *result);
+void RE_engine_end_result(struct RenderEngine *engine, struct RenderResult *result, int cancel);
 int RE_engine_test_break(struct RenderEngine *engine);
 void RE_engine_update_stats(struct RenderEngine *engine, const char *stats, const char *info);
 void RE_engine_update_progress(struct RenderEngine *engine, float progress);
@@ -55,7 +55,6 @@ void rna_ColorRamp_eval(void *coba, float position, float color[4]);
 void rna_Scene_frame_set(void *scene, int frame, float subframe);
 void BKE_image_user_frame_calc(void *iuser, int cfra, int fieldnr);
 void BKE_image_user_file_path(void *iuser, void *ima, char *path);
-
 }
 
 CCL_NAMESPACE_BEGIN
@@ -171,7 +170,7 @@ static inline uint get_layer(BL::Array<int, 20> array)
 	return layer;
 }
 
-static inline uint get_layer(BL::Array<int, 20> array, BL::Array<int, 8> local_array, bool is_light = false)
+static inline uint get_layer(BL::Array<int, 20> array, BL::Array<int, 8> local_array, bool use_local, bool is_light = false)
 {
 	uint layer = 0;
 
@@ -189,7 +188,14 @@ static inline uint get_layer(BL::Array<int, 20> array, BL::Array<int, 8> local_a
 			if(local_array[i])
 				layer |= (1 << (20+i));
 	}
-	
+
+	/* we don't have spare bits for localview (normally 20-28) because
+	 * PATH_RAY_LAYER_SHIFT uses 20-32. So - check if we have localview and if
+	 * so, shift local view bits down to 1-8, since this is done for the view
+	 * port only - it should be OK and not conflict with render layers. */
+	if(use_local)
+		layer >>= 20;
+
 	return layer;
 }