J-key render switching back, now with 10 slots.

Implementation note: this was done by giving each Render a slot number,
and for every slot a new Render will be created. Not sure if this is
ideal, but it ensures that all passes, render info, etc are separate so
you can also compare render layers and passes, in 2.4x only whatever it
was currently displaying was backed up.

5 files changed, 78 insertions, 31 deletions

diff --git a/source/blender/render/extern/include/RE_pipeline.h b/source/blender/render/extern/include/RE_pipeline.h
index a90220b9c1b..4084958488c 100644
--- a/source/blender/render/extern/include/RE_pipeline.h
+++ b/source/blender/render/extern/include/RE_pipeline.h
@@ -146,8 +146,21 @@ typedef struct RenderStats {
 
 /* the name is used as identifier, so elsewhere in blender the result can retrieved */
 /* calling a new render with same name, frees automatic existing render */
-struct Render *RE_NewRender (const char *name);
-struct Render *RE_GetRender(const char *name);
+struct Render *RE_NewRender (const char *name, int slot);
+struct Render *RE_GetRender(const char *name, int slot);
+
+/* render slots. for most cases like baking or preview render this will
+   always be default, for actual render multiple slots can be used. in
+   that case 'rendering' is the slot being rendered to, and 'view' is the
+   slot being viewed. these are always the same except if the currently
+   viewed slot is changed during render, at the end they will be synced. */
+#define RE_SLOT_RENDERING	-2
+#define RE_SLOT_VIEW		-1
+#define RE_SLOT_DEFAULT		 0
+#define RE_SLOT_MAX			10
+
+void RE_SetViewSlot(int slot);
+int RE_GetViewSlot(void);
 
 /* returns 1 while render is working (or renders called from within render) */
 int RE_RenderInProgress(struct Render *re);
diff --git a/source/blender/render/intern/include/render_types.h b/source/blender/render/intern/include/render_types.h
index de7d176759e..c4465781940 100644
--- a/source/blender/render/intern/include/render_types.h
+++ b/source/blender/render/intern/include/render_types.h
@@ -113,6 +113,7 @@ struct Render
 {
 	struct Render *next, *prev;
 	char name[RE_MAXNAME];
+	int slot;
 	
 	/* state settings */
 	short flag, osa, ok, result_ok;
diff --git a/source/blender/render/intern/source/convertblender.c b/source/blender/render/intern/source/convertblender.c
index d05d88266c7..a24fa47ec3e 100644
--- a/source/blender/render/intern/source/convertblender.c
+++ b/source/blender/render/intern/source/convertblender.c
@@ -5605,7 +5605,7 @@ void RE_make_sticky(Scene *scene, View3D *v3d)
 		return;
 	}
 	
-	re= RE_NewRender("_make sticky_");
+	re= RE_NewRender("_make sticky_", RE_SLOT_DEFAULT);
 	RE_InitState(re, NULL, &scene->r, NULL, scene->r.xsch, scene->r.ysch, NULL);
 	
 	/* use renderdata and camera to set viewplane */
diff --git a/source/blender/render/intern/source/envmap.c b/source/blender/render/intern/source/envmap.c
index 7ba860955b3..0ab0b1c4141 100644
--- a/source/blender/render/intern/source/envmap.c
+++ b/source/blender/render/intern/source/envmap.c
@@ -108,7 +108,7 @@ static Render *envmap_render_copy(Render *re, EnvMap *env)
 	Render *envre;
 	int cuberes;
 	
-	envre= RE_NewRender("Envmap");
+	envre= RE_NewRender("Envmap", RE_SLOT_DEFAULT);
 	
 	env->lastsize= re->r.size;
 	cuberes = (env->cuberes * re->r.size) / 100;
diff --git a/source/blender/render/intern/source/pipeline.c b/source/blender/render/intern/source/pipeline.c
index f679b35c627..c5d4392a53c 100644
--- a/source/blender/render/intern/source/pipeline.c
+++ b/source/blender/render/intern/source/pipeline.c
@@ -108,14 +108,19 @@
 /* ********* globals ******** */
 
 /* here we store all renders */
-static struct ListBase RenderList= {NULL, NULL};
+static struct {
+	ListBase renderlist;
+
+	/* render slots */
+	int viewslot, renderingslot;
+
+	/* commandline thread override */
+	int threads;
+} RenderGlobal = {{NULL, NULL}, 0, 0, -1}; 
 
 /* hardcopy of current render, used while rendering for speed */
 Render R;
 
-/* commandline thread override */
-static int commandline_threads= -1;
-
 /* ********* alloc and free ******** */
 
 
@@ -228,11 +233,11 @@ static void push_render_result(Render *re)
 /* if scemode is R_SINGLE_LAYER, at end of rendering, merge the both render results */
 static void pop_render_result(Render *re)
 {
-	
 	if(re->result==NULL) {
 		printf("pop render result error; no current result!\n");
 		return;
 	}
+
 	if(re->pushedresult) {
 		BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
 
@@ -989,13 +994,35 @@ static void read_render_result(Render *re, int sample)
 
 /* *************************************************** */
 
-Render *RE_GetRender(const char *name)
+void RE_SetViewSlot(int slot)
+{
+	RenderGlobal.viewslot = slot;
+}
+
+int RE_GetViewSlot(void)
+{
+	return RenderGlobal.viewslot;
+}
+
+static int re_get_slot(int slot)
+{
+	if(slot == RE_SLOT_VIEW)
+		return RenderGlobal.viewslot;
+	else if(slot == RE_SLOT_RENDERING)
+		return (G.rendering)? RenderGlobal.renderingslot: RenderGlobal.viewslot;
+
+	return slot;
+}
+
+Render *RE_GetRender(const char *name, int slot)
 {
 	Render *re;
+
+	slot= re_get_slot(slot);
 	
 	/* search for existing renders */
-	for(re= RenderList.first; re; re= re->next) {
-		if(strncmp(re->name, name, RE_MAXNAME)==0) {
+	for(re= RenderGlobal.renderlist.first; re; re= re->next) {
+		if(strncmp(re->name, name, RE_MAXNAME)==0 && re->slot==slot) {
 			break;
 		}
 	}
@@ -1126,24 +1153,26 @@ void RE_ResultGet32(Render *re, unsigned int *rect)
 	RE_ReleaseResultImage(re);
 }
 
-
 RenderStats *RE_GetStats(Render *re)
 {
 	return &re->i;
 }
 
-Render *RE_NewRender(const char *name)
+Render *RE_NewRender(const char *name, int slot)
 {
 	Render *re;
+
+	slot= re_get_slot(slot);
 	
 	/* only one render per name exists */
-	re= RE_GetRender(name);
+	re= RE_GetRender(name, slot);
 	if(re==NULL) {
 		
 		/* new render data struct */
 		re= MEM_callocN(sizeof(Render), "new render");
-		BLI_addtail(&RenderList, re);
+		BLI_addtail(&RenderGlobal.renderlist, re);
 		strncpy(re->name, name, RE_MAXNAME);
+		re->slot= slot;
 		BLI_rw_mutex_init(&re->resultmutex);
 	}
 	
@@ -1178,15 +1207,15 @@ void RE_FreeRender(Render *re)
 	RE_FreeRenderResult(re->result);
 	RE_FreeRenderResult(re->pushedresult);
 	
-	BLI_remlink(&RenderList, re);
+	BLI_remlink(&RenderGlobal.renderlist, re);
 	MEM_freeN(re);
 }
 
 /* exit blender */
 void RE_FreeAllRender(void)
 {
-	while(RenderList.first) {
-		RE_FreeRender(RenderList.first);
+	while(RenderGlobal.renderlist.first) {
+		RE_FreeRender(RenderGlobal.renderlist.first);
 	}
 }
 
@@ -2186,7 +2215,7 @@ static void do_render_fields_blur_3d(Render *re)
 */
 static void render_scene(Render *re, Scene *sce, int cfra)
 {
-	Render *resc= RE_NewRender(sce->id.name);
+	Render *resc= RE_NewRender(sce->id.name, RE_SLOT_RENDERING);
 	int winx= re->winx, winy= re->winy;
 	
 	sce->r.cfra= cfra;
@@ -2313,7 +2342,7 @@ static void do_merge_fullsample(Render *re, bNodeTree *ntree)
 			Render *re1;
 			
 			tag_scenes_for_render(re);
-			for(re1= RenderList.first; re1; re1= re1->next) {
+			for(re1= RenderGlobal.renderlist.first; re1; re1= re1->next) {
 				if(re1->scene->id.flag & LIB_DOIT)
 					if(re1->r.scemode & R_FULL_SAMPLE)
 						read_render_result(re1, sample);
@@ -2475,7 +2504,7 @@ static void do_render_composite_fields_blur_3d(Render *re)
 static void renderresult_stampinfo(Scene *scene)
 {
 	RenderResult rres;
-	Render *re= RE_GetRender(scene->id.name);
+	Render *re= RE_GetRender(scene->id.name, RE_SLOT_RENDERING);
 
 	/* this is the basic trick to get the displayed float or char rect from render result */
 	RE_AcquireResultImage(re, &rres);
@@ -2784,8 +2813,9 @@ static int render_initialize_from_scene(Render *re, Scene *scene, SceneRenderLay
 void RE_BlenderFrame(Render *re, Scene *scene, SceneRenderLayer *srl, int frame)
 {
 	/* ugly global still... is to prevent preview events and signal subsurfs etc to make full resol */
-	G.rendering= 1;
+	RenderGlobal.renderingslot= re->slot;
 	re->result_ok= 0;
+	G.rendering= 1;
 	
 	scene->r.cfra= frame;
 	
@@ -2794,8 +2824,9 @@ void RE_BlenderFrame(Render *re, Scene *scene, SceneRenderLayer *srl, int frame)
 	}
 	
 	/* UGLY WARNING */
-	G.rendering= 0;
 	re->result_ok= 1;
+	G.rendering= 0;
+	RenderGlobal.renderingslot= RenderGlobal.viewslot;
 }
 
 static int do_write_image_or_movie(Render *re, Scene *scene, bMovieHandle *mh, ReportList *reports)
@@ -2899,6 +2930,7 @@ void RE_BlenderAnim(Render *re, Scene *scene, int sfra, int efra, int tfra, Repo
 	/* ugly global still... is to prevent renderwin events and signal subsurfs etc to make full resol */
 	/* is also set by caller renderwin.c */
 	G.rendering= 1;
+	RenderGlobal.renderingslot= re->slot;
 	re->result_ok= 0;
 	
 	if(BKE_imtype_is_movie(scene->r.imtype))
@@ -2995,6 +3027,7 @@ void RE_BlenderAnim(Render *re, Scene *scene, int sfra, int efra, int tfra, Repo
 	/* UGLY WARNING */
 	G.rendering= 0;
 	re->result_ok= 1;
+	RenderGlobal.renderingslot= RenderGlobal.viewslot;
 }
 
 /* note; repeated win/disprect calc... solve that nicer, also in compo */
@@ -3028,9 +3061,9 @@ void RE_ReadRenderResult(Scene *scene, Scene *scenode)
 		scene= scenode;
 	
 	/* get render: it can be called from UI with draw callbacks */
-	re= RE_GetRender(scene->id.name);
+	re= RE_GetRender(scene->id.name, RE_SLOT_VIEW);
 	if(re==NULL)
-		re= RE_NewRender(scene->id.name);
+		re= RE_NewRender(scene->id.name, RE_SLOT_VIEW);
 	RE_InitState(re, NULL, &scene->r, NULL, winx, winy, &disprect);
 	re->scene= scene;
 	
@@ -3040,9 +3073,9 @@ void RE_ReadRenderResult(Scene *scene, Scene *scenode)
 void RE_set_max_threads(int threads)
 {
 	if (threads==0) {
-		commandline_threads = BLI_system_thread_count();
+		RenderGlobal.threads = BLI_system_thread_count();
 	} else if(threads>=1 && threads<=BLENDER_MAX_THREADS) {
-		commandline_threads= threads;
+		RenderGlobal.threads= threads;
 	} else {
 		printf("Error, threads has to be in range 0-%d\n", BLENDER_MAX_THREADS);
 	}
@@ -3050,9 +3083,9 @@ void RE_set_max_threads(int threads)
 
 void RE_init_threadcount(Render *re) 
 {
-        if(commandline_threads >= 1) { /* only set as an arg in background mode */
-		re->r.threads= MIN2(commandline_threads, BLENDER_MAX_THREADS);
-	} else if ((re->r.mode & R_FIXED_THREADS)==0 || commandline_threads == 0) { /* Automatic threads */
+	if(RenderGlobal.threads >= 1) { /* only set as an arg in background mode */
+		re->r.threads= MIN2(RenderGlobal.threads, BLENDER_MAX_THREADS);
+	} else if ((re->r.mode & R_FIXED_THREADS)==0 || RenderGlobal.threads == 0) { /* Automatic threads */
 		re->r.threads = BLI_system_thread_count();
 	}
 }