Cycles: persistent images option

This option enables keeping loaded images in the memory in-between
of rendering.

Implemented by keeping render engine alive for until Render structure
is being freed.

Cycles will free all data when render finishes, optionally keeping
image manager untouched. All shaders, meshes, objects will be
re-allocated next time rendering happens.

Cycles cession and scene will be re-created from scratch if render/
scene parameters were changed.

This will also allow to keep compiled OSL shaders in memory without
need to re-compile them again.

P.S. Performance panel could be cleaned up a bit, not so much happy
     with it's vertical alignment currently but not sure how to make
     it look better.

 P.P.S. Currently the only way to free images from the device is to
       disable Persistent Images option and start rendering.

4 files changed, 83 insertions, 32 deletions

diff --git a/intern/cycles/render/scene.cpp b/intern/cycles/render/scene.cpp
index 15031b9500c..a2febc31f60 100644
--- a/intern/cycles/render/scene.cpp
+++ b/intern/cycles/render/scene.cpp
@@ -62,33 +62,11 @@ Scene::Scene(const SceneParams& params_, const DeviceInfo& device_info_)
 
 Scene::~Scene()
 {
-	if(device) camera->device_free(device, &dscene);
-	delete camera;
-
-	if(device) filter->device_free(device, &dscene);
-	delete filter;
-
-	if(device) film->device_free(device, &dscene);
-	delete film;
-
-	if(device) background->device_free(device, &dscene);
-	delete background;
-
-	if(device) mesh_manager->device_free(device, &dscene);
-	delete mesh_manager;
-
-	if(device) object_manager->device_free(device, &dscene);
-	delete object_manager;
-
-	if(device) integrator->device_free(device, &dscene);
-	delete integrator;
-
-	if(device) shader_manager->device_free(device, &dscene);
-	delete shader_manager;
-
-	if(device) light_manager->device_free(device, &dscene);
-	delete light_manager;
+	free_memory(true);
+}
 
+void Scene::free_memory(bool final)
+{
 	foreach(Shader *s, shaders)
 		delete s;
 	foreach(Mesh *m, meshes)
@@ -100,11 +78,44 @@ Scene::~Scene()
 	foreach(ParticleSystem *p, particle_systems)
 		delete p;
 
-	if(device) image_manager->device_free(device, &dscene);
-	delete image_manager;
-
-	if(device) particle_system_manager->device_free(device, &dscene);
-	delete particle_system_manager;
+	if(device) {
+		camera->device_free(device, &dscene);
+		filter->device_free(device, &dscene);
+		film->device_free(device, &dscene);
+		background->device_free(device, &dscene);
+		integrator->device_free(device, &dscene);
+
+		object_manager->device_free(device, &dscene);
+		mesh_manager->device_free(device, &dscene);
+		shader_manager->device_free(device, &dscene);
+		light_manager->device_free(device, &dscene);
+
+		particle_system_manager->device_free(device, &dscene);
+
+		if(!params.persistent_images || final)
+			image_manager->device_free(device, &dscene);
+	}
+
+	if(final) {
+		delete filter;
+		delete camera;
+		delete film;
+		delete background;
+		delete integrator;
+		delete object_manager;
+		delete mesh_manager;
+		delete shader_manager;
+		delete light_manager;
+		delete particle_system_manager;
+		delete image_manager;
+	}
+	else {
+		shaders.clear();
+		meshes.clear();
+		objects.clear();
+		lights.clear();
+		particle_systems.clear();
+	}
 }
 
 void Scene::device_update(Device *device_, Progress& progress)
@@ -229,5 +240,22 @@ bool Scene::need_reset()
 		|| particle_system_manager->need_update);
 }
 
+void Scene::reset()
+{
+	shader_manager->add_default(this);
+
+	/* ensure all objects are updated */
+	camera->tag_update();
+	filter->tag_update(this);
+	film->tag_update(this);
+	background->tag_update(this);
+	integrator->tag_update(this);
+}
+
+void Scene::device_free()
+{
+	free_memory(false);
+}
+
 CCL_NAMESPACE_END
 
diff --git a/intern/cycles/render/scene.h b/intern/cycles/render/scene.h
index bd45c1c04e6..92ef692b4b9 100644
--- a/intern/cycles/render/scene.h
+++ b/intern/cycles/render/scene.h
@@ -120,6 +120,7 @@ public:
 	bool use_bvh_cache;
 	bool use_bvh_spatial_split;
 	bool use_qbvh;
+	bool persistent_images;
 
 	SceneParams()
 	{
@@ -139,7 +140,8 @@ public:
 		&& bvh_type == params.bvh_type
 		&& use_bvh_cache == params.use_bvh_cache
 		&& use_bvh_spatial_split == params.use_bvh_spatial_split
-		&& use_qbvh == params.use_qbvh); }
+		&& use_qbvh == params.use_qbvh
+		&& persistent_images == params.persistent_images); }
 };
 
 /* Scene */
@@ -198,6 +200,12 @@ public:
 
 	bool need_update();
 	bool need_reset();
+
+	void reset();
+	void device_free();
+
+protected:
+	void free_memory(bool final);
 };
 
 CCL_NAMESPACE_END
diff --git a/intern/cycles/render/session.cpp b/intern/cycles/render/session.cpp
index 7f6b43c1e00..41212c2db84 100644
--- a/intern/cycles/render/session.cpp
+++ b/intern/cycles/render/session.cpp
@@ -842,4 +842,18 @@ bool Session::update_progressive_refine(bool cancel)
 	return write;
 }
 
+void Session::device_free()
+{
+	scene->device_free();
+
+	foreach(RenderBuffers *buffers, tile_buffers)
+		delete buffers;
+
+	tile_buffers.clear();
+
+	/* used from background render only, so no need to
+	 * re-create render/display buffers here
+	 */
+}
+
 CCL_NAMESPACE_END
diff --git a/intern/cycles/render/session.h b/intern/cycles/render/session.h
index 7bb0cd1ae01..cfc1502287d 100644
--- a/intern/cycles/render/session.h
+++ b/intern/cycles/render/session.h
@@ -130,6 +130,7 @@ public:
 	void set_samples(int samples);
 	void set_pause(bool pause);
 
+	void device_free();
 protected:
 	struct DelayedReset {
 		thread_mutex mutex;