Fix T93382: Blender still generates subsurface render passes

In T93382, the problem was that the Blender-side rendering code was
still generating the subsurface passes because the old render pass
flags were set, even though Cycles doesn't generate them anymore.

After a closer look, it turns out that the entire hardcoded pass
creation code can be removed. We already have an Engine API function
to query the list of render passes from the engine, so we might as
well just call that and create the returned passes.

Turns out that Eevee already did this anyways. On the Cycles side, it
allows to deduplicate a lot of `BlenderSync::sync_render_passes`.
Before, passes were defined in engine.py and in sync.cpp. Now, all
passes that engine.py returns are created automatically, so sync.cpp
only needs to handle a few special cases.

I'm not really concerned about affecting external renderer addons,
since they already needed to handle the old "builtin passes" in
their Engine API implementation anyways to make them show up in the
compositor. So, unless they missed that for like 10 releases, they
should not notice any difference.

Differential Revision: https://developer.blender.org/D16295

3 files changed, 46 insertions, 114 deletions

diff --git a/source/blender/draw/intern/draw_manager.c b/source/blender/draw/intern/draw_manager.c
index da77845feb4..b9a9780e651 100644
--- a/source/blender/draw/intern/draw_manager.c
+++ b/source/blender/draw/intern/draw_manager.c
@@ -1959,20 +1959,6 @@ void DRW_render_gpencil(struct RenderEngine *engine, struct Depsgraph *depsgraph
   DST.buffer_finish_called = false;
 }
 
-/* Callback function for RE_engine_update_render_passes to ensure all
- * render passes are registered. */
-static void draw_render_result_ensure_pass_cb(void *user_data,
-                                              struct Scene *UNUSED(scene),
-                                              struct ViewLayer *view_layer,
-                                              const char *name,
-                                              int channels,
-                                              const char *chanid,
-                                              eNodeSocketDatatype UNUSED(type))
-{
-  RenderEngine *engine = user_data;
-  RE_engine_add_pass(engine, name, channels, chanid, view_layer->name);
-}
-
 void DRW_render_to_image(RenderEngine *engine, struct Depsgraph *depsgraph)
 {
   Scene *scene = DEG_get_evaluated_scene(depsgraph);
@@ -2023,10 +2009,6 @@ void DRW_render_to_image(RenderEngine *engine, struct Depsgraph *depsgraph)
   /* set default viewport */
   GPU_viewport(0, 0, size[0], size[1]);
 
-  /* Update the render passes. This needs to be done before acquiring the render result. */
-  RE_engine_update_render_passes(
-      engine, scene, view_layer, draw_render_result_ensure_pass_cb, engine);
-
   /* Init render result. */
   RenderResult *render_result = RE_engine_begin_result(engine,
                                                        0,
diff --git a/source/blender/render/intern/engine.cc b/source/blender/render/intern/engine.cc
index 5eb4db6faa4..b8757d33580 100644
--- a/source/blender/render/intern/engine.cc
+++ b/source/blender/render/intern/engine.cc
@@ -969,6 +969,40 @@ static void engine_render_view_layer(Render *re,
   engine_depsgraph_exit(engine);
 }
 
+/* Callback function for engine_render_create_result to add all render passes to the result. */
+static void engine_render_add_result_pass_cb(void *user_data,
+                                             struct Scene *UNUSED(scene),
+                                             struct ViewLayer *view_layer,
+                                             const char *name,
+                                             int channels,
+                                             const char *chanid,
+                                             eNodeSocketDatatype UNUSED(type))
+{
+  RenderResult *rr = (RenderResult *)user_data;
+  RE_create_render_pass(rr, name, channels, chanid, view_layer->name, RR_ALL_VIEWS, false);
+}
+
+static RenderResult *engine_render_create_result(Render *re)
+{
+  RenderResult *rr = render_result_new(re, &re->disprect, RR_ALL_LAYERS, RR_ALL_VIEWS);
+  if (rr == nullptr) {
+    return nullptr;
+  }
+
+  FOREACH_VIEW_LAYER_TO_RENDER_BEGIN (re, view_layer) {
+    RE_engine_update_render_passes(
+        re->engine, re->scene, view_layer, engine_render_add_result_pass_cb, rr);
+  }
+  FOREACH_VIEW_LAYER_TO_RENDER_END;
+
+  /* Preview does not support deferred render result allocation. */
+  if (re->r.scemode & R_BUTS_PREVIEW) {
+    render_result_passes_allocated_ensure(rr);
+  }
+
+  return rr;
+}
+
 bool RE_engine_render(Render *re, bool do_all)
 {
   RenderEngineType *type = RE_engines_find(re->r.engine);
@@ -1008,6 +1042,14 @@ bool RE_engine_render(Render *re, bool do_all)
     render_update_anim_renderdata(re, &re->scene->r, &re->scene->view_layers);
   }
 
+  /* Create engine. */
+  RenderEngine *engine = re->engine;
+
+  if (!engine) {
+    engine = RE_engine_create(type);
+    re->engine = engine;
+  }
+
   /* create render result */
   BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
   if (re->result == nullptr || !(re->r.scemode & R_BUTS_PREVIEW)) {
@@ -1015,7 +1057,7 @@ bool RE_engine_render(Render *re, bool do_all)
       render_result_free(re->result);
     }
 
-    re->result = render_result_new(re, &re->disprect, RR_ALL_LAYERS, RR_ALL_VIEWS);
+    re->result = engine_render_create_result(re);
   }
   BLI_rw_mutex_unlock(&re->resultmutex);
 
@@ -1024,6 +1066,9 @@ bool RE_engine_render(Render *re, bool do_all)
     if (re->draw_lock) {
       re->draw_lock(re->dlh, false);
     }
+    /* Free engine. */
+    RE_engine_free(engine);
+    re->engine = nullptr;
     /* Too small image is handled earlier, here it could only happen if
      * there was no sufficient memory to allocate all passes.
      */
@@ -1036,14 +1081,6 @@ bool RE_engine_render(Render *re, bool do_all)
   re->i.cfra = re->scene->r.cfra;
   BLI_strncpy(re->i.scene_name, re->scene->id.name + 2, sizeof(re->i.scene_name));
 
-  /* render */
-  RenderEngine *engine = re->engine;
-
-  if (!engine) {
-    engine = RE_engine_create(type);
-    re->engine = engine;
-  }
-
   engine->flag |= RE_ENGINE_RENDERING;
 
   /* TODO: actually link to a parent which shouldn't happen */
diff --git a/source/blender/render/intern/render_result.cc b/source/blender/render/intern/render_result.cc
index bd5c6a0f5c4..f9524fdbf05 100644
--- a/source/blender/render/intern/render_result.cc
+++ b/source/blender/render/intern/render_result.cc
@@ -290,90 +290,8 @@ RenderResult *render_result_new(Render *re,
         }
       }
 
-#define RENDER_LAYER_ADD_PASS_SAFE(rr, rl, channels, name, viewname, chan_id) \
-  do { \
-    if (render_layer_add_pass(rr, rl, channels, name, viewname, chan_id, false) == nullptr) { \
-      render_result_free(rr); \
-      return nullptr; \
-    } \
-  } while (false)
-
       /* A render-layer should always have a "Combined" pass. */
       render_layer_add_pass(rr, rl, 4, "Combined", view, "RGBA", false);
-
-      if (view_layer->passflag & SCE_PASS_Z) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 1, RE_PASSNAME_Z, view, "Z");
-      }
-      if (view_layer->passflag & SCE_PASS_VECTOR) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 4, RE_PASSNAME_VECTOR, view, "XYZW");
-      }
-      if (view_layer->passflag & SCE_PASS_NORMAL) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_NORMAL, view, "XYZ");
-      }
-      if (view_layer->passflag & SCE_PASS_POSITION) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_POSITION, view, "XYZ");
-      }
-      if (view_layer->passflag & SCE_PASS_UV) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_UV, view, "UVA");
-      }
-      if (view_layer->passflag & SCE_PASS_EMIT) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_EMIT, view, "RGB");
-      }
-      if (view_layer->passflag & SCE_PASS_AO) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_AO, view, "RGB");
-      }
-      if (view_layer->passflag & SCE_PASS_ENVIRONMENT) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_ENVIRONMENT, view, "RGB");
-      }
-      if (view_layer->passflag & SCE_PASS_SHADOW) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_SHADOW, view, "RGB");
-      }
-      if (view_layer->passflag & SCE_PASS_INDEXOB) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 1, RE_PASSNAME_INDEXOB, view, "X");
-      }
-      if (view_layer->passflag & SCE_PASS_INDEXMA) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 1, RE_PASSNAME_INDEXMA, view, "X");
-      }
-      if (view_layer->passflag & SCE_PASS_MIST) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 1, RE_PASSNAME_MIST, view, "Z");
-      }
-      if (view_layer->passflag & SCE_PASS_DIFFUSE_DIRECT) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_DIFFUSE_DIRECT, view, "RGB");
-      }
-      if (view_layer->passflag & SCE_PASS_DIFFUSE_INDIRECT) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_DIFFUSE_INDIRECT, view, "RGB");
-      }
-      if (view_layer->passflag & SCE_PASS_DIFFUSE_COLOR) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_DIFFUSE_COLOR, view, "RGB");
-      }
-      if (view_layer->passflag & SCE_PASS_GLOSSY_DIRECT) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_GLOSSY_DIRECT, view, "RGB");
-      }
-      if (view_layer->passflag & SCE_PASS_GLOSSY_INDIRECT) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_GLOSSY_INDIRECT, view, "RGB");
-      }
-      if (view_layer->passflag & SCE_PASS_GLOSSY_COLOR) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_GLOSSY_COLOR, view, "RGB");
-      }
-      if (view_layer->passflag & SCE_PASS_TRANSM_DIRECT) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_TRANSM_DIRECT, view, "RGB");
-      }
-      if (view_layer->passflag & SCE_PASS_TRANSM_INDIRECT) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_TRANSM_INDIRECT, view, "RGB");
-      }
-      if (view_layer->passflag & SCE_PASS_TRANSM_COLOR) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_TRANSM_COLOR, view, "RGB");
-      }
-      if (view_layer->passflag & SCE_PASS_SUBSURFACE_DIRECT) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_SUBSURFACE_DIRECT, view, "RGB");
-      }
-      if (view_layer->passflag & SCE_PASS_SUBSURFACE_INDIRECT) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_SUBSURFACE_INDIRECT, view, "RGB");
-      }
-      if (view_layer->passflag & SCE_PASS_SUBSURFACE_COLOR) {
-        RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_SUBSURFACE_COLOR, view, "RGB");
-      }
-#undef RENDER_LAYER_ADD_PASS_SAFE
     }
   }
   FOREACH_VIEW_LAYER_TO_RENDER_END;
@@ -411,11 +329,6 @@ RenderResult *render_result_new(Render *re,
   rr->xof = re->disprect.xmin + BLI_rcti_cent_x(&re->disprect) - (re->winx / 2);
   rr->yof = re->disprect.ymin + BLI_rcti_cent_y(&re->disprect) - (re->winy / 2);
 
-  /* Preview does not support deferred render result allocation. */
-  if (re->r.scemode & R_BUTS_PREVIEW) {
-    render_result_passes_allocated_ensure(rr);
-  }
-
   return rr;
 }