Merge branch 'blender2.7'
authorLukas Stockner <lukas.stockner@freenet.de>
Fri, 18 Jan 2019 00:47:32 +0000 (01:47 +0100)
committerLukas Stockner <lukas.stockner@freenet.de>
Fri, 18 Jan 2019 00:47:32 +0000 (01:47 +0100)
1  2 
source/blender/nodes/composite/nodes/node_composite_image.c
source/blender/render/extern/include/RE_engine.h
source/blender/render/intern/include/render_result.h
source/blender/render/intern/source/external_engine.c
source/blender/render/intern/source/render_result.c

@@@ -214,6 -213,21 +214,23 @@@ void node_cmp_rlayers_register_pass(bNo
        }
  }
  
 -static void cmp_node_rlayer_create_outputs_cb(RenderEngine *UNUSED(engine), Scene *scene, SceneRenderLayer *srl,
++static void cmp_node_rlayer_create_outputs_cb(RenderEngine *UNUSED(engine), Scene *scene, ViewLayer *view_layer,
+                                               const char *name, int UNUSED(channels), const char *UNUSED(chanid), int type)
+ {
+       /* Register the pass in all scenes that have a render layer node for this layer.
+        * Since multiple scenes can be used in the compositor, the code must loop over all scenes
+        * and check whether their nodetree has a node that needs to be updated. */
+       /* NOTE: using G_MAIN seems valid here,
+        * unless we want to register that for every other temp Main we could generate??? */
++      ntreeCompositRegisterPass(scene->nodetree, scene, view_layer, name, type);
++
+       for (Scene *sce = G_MAIN->scene.first; sce; sce = sce->id.next) {
 -              if (sce->nodetree) {
 -                      ntreeCompositRegisterPass(sce->nodetree, scene, srl, name, type);
++              if (sce->nodetree && sce != scene) {
++                      ntreeCompositRegisterPass(sce->nodetree, scene, view_layer, name, type);
+               }
+       }
+ }
  static void cmp_node_rlayer_create_outputs(bNodeTree *ntree, bNode *node, LinkNodePair *available_sockets)
  {
        Scene *scene = (Scene *)node->id;
                                node->storage = data;
  
                                RenderEngine *engine = RE_engine_create(engine_type);
-                               engine_type->update_render_passes(engine, scene, view_layer);
 -                              RE_engine_update_render_passes(engine, scene, srl, cmp_node_rlayer_create_outputs_cb);
++                              RE_engine_update_render_passes(engine, scene, view_layer, cmp_node_rlayer_create_outputs_cb);
                                RE_engine_free(engine);
  
                                MEM_freeN(data);
  #include "RNA_types.h"
  #include "RE_bake.h"
  
+ #include "BLI_threads.h"
  struct bNode;
  struct bNodeTree;
 +struct BakePixel;
 +struct Depsgraph;
 +struct IDProperty;
 +struct Main;
  struct Object;
  struct Render;
  struct RenderData;
@@@ -111,6 -104,9 +113,9 @@@ typedef struct RenderEngineType 
        ExtensionRNA ext;
  } RenderEngineType;
  
 -typedef void (*update_render_passes_cb_t)(struct RenderEngine *engine, struct Scene *scene, struct SceneRenderLayer *srl,
++typedef void (*update_render_passes_cb_t)(struct RenderEngine *engine, struct Scene *scene, struct ViewLayer *view_layer,
+                                           const char *name, int channels, const char *chanid, int type);
  typedef struct RenderEngine {
        RenderEngineType *type;
        void *py_instance;
@@@ -175,7 -172,9 +184,9 @@@ bool RE_engine_is_external(struct Rende
  
  void RE_engine_frame_set(struct RenderEngine *engine, int frame, float subframe);
  
 -void RE_engine_update_render_passes(struct RenderEngine *engine, struct Scene *scene, struct SceneRenderLayer *srl,
++void RE_engine_update_render_passes(struct RenderEngine *engine, struct Scene *scene, struct ViewLayer *view_layer,
+                                     update_render_passes_cb_t callback);
 -void RE_engine_register_pass(struct RenderEngine *engine, struct Scene *scene, struct SceneRenderLayer *srl,
 +void RE_engine_register_pass(struct RenderEngine *engine, struct Scene *scene, struct ViewLayer *view_layer,
                               const char *name, int channels, const char *chanid, int type);
  
  /* Engine Types */
@@@ -711,8 -728,11 +715,8 @@@ int RE_engine_render(Render *re, int do
        engine->tile_y = re->party;
  
        if (re->result->do_exr_tile)
-               render_result_exr_file_begin(re);
+               render_result_exr_file_begin(re, engine);
  
 -      if (type->update)
 -              type->update(engine, re->main, re->scene);
 -
        /* Clear UI drawing locks. */
        if (re->draw_lock) {
                re->draw_lock(re->dlh, 0);
        return 1;
  }
  
- void RE_engine_register_pass(struct RenderEngine *engine, struct Scene *scene, struct ViewLayer *view_layer,
-                              const char *name, int UNUSED(channels), const char *UNUSED(chanid), int type)
 -void RE_engine_update_render_passes(struct RenderEngine *engine, struct Scene *scene, struct SceneRenderLayer *srl,
++void RE_engine_update_render_passes(struct RenderEngine *engine, struct Scene *scene, struct ViewLayer *view_layer,
+                                     update_render_passes_cb_t callback)
  {
-       /* The channel information is currently not used, but is part of the API in case it's needed in the future. */
-       if (!(scene && view_layer && engine)) {
 -      if (!(scene && srl && engine && callback && engine->type->update_render_passes)) {
++      if (!(scene && view_layer && engine && callback && engine->type->update_render_passes)) {
                return;
        }
  
-       /* Register the pass in all scenes that have a render layer node for this layer.
-        * Since multiple scenes can be used in the compositor, the code must loop over all scenes
-        * and check whether their nodetree has a node that needs to be updated. */
-       /* NOTE: using G_MAIN seems valid here,
-        * unless we want to register that for every other temp Main we could generate??? */
-       ntreeCompositRegisterPass(scene->nodetree, scene, view_layer, name, type);
+       BLI_mutex_lock(&engine->update_render_passes_mutex);
  
-       for (Scene *sce = G_MAIN->scene.first; sce; sce = sce->id.next) {
-               if (sce->nodetree && sce != scene) {
-                       ntreeCompositRegisterPass(sce->nodetree, scene, view_layer, name, type);
-               }
+       engine->update_render_passes_cb = callback;
 -      engine->type->update_render_passes(engine, scene, srl);
++      engine->type->update_render_passes(engine, scene, view_layer);
+       BLI_mutex_unlock(&engine->update_render_passes_mutex);
+ }
 -void RE_engine_register_pass(struct RenderEngine *engine, struct Scene *scene, struct SceneRenderLayer *srl,
++void RE_engine_register_pass(struct RenderEngine *engine, struct Scene *scene, struct ViewLayer *view_layer,
+                              const char *name, int channels, const char *chanid, int type)
+ {
 -      if (!(scene && srl && engine && engine->update_render_passes_cb)) {
++      if (!(scene && view_layer && engine && engine->update_render_passes_cb)) {
+               return;
        }
 -      engine->update_render_passes_cb(engine, scene, srl, name, channels, chanid, type);
++      engine->update_render_passes_cb(engine, scene, view_layer, name, channels, chanid, type);
 +}
 +
 +void RE_engine_free_blender_memory(RenderEngine *engine)
 +{
 +      /* Weak way to save memory, but not crash grease pencil.
 +       *
 +       * TODO(sergey): Find better solution for this.
 +       * TODO(sergey): Try to find solution which does not involve looping over
 +       * all the objects.
 +       */
 +      if (DRW_render_check_grease_pencil(engine->depsgraph)) {
 +              return;
 +      }
 +      DEG_graph_free(engine->depsgraph);
 +      engine->depsgraph = NULL;
  }
@@@ -1063,8 -1116,25 +1066,25 @@@ void render_result_save_empty_result_ti
        }
  }
  
 -static void render_result_register_pass_cb(RenderEngine *engine, Scene *UNUSED(scene), SceneRenderLayer *srl,
++static void render_result_register_pass_cb(RenderEngine *engine, Scene *UNUSED(scene), ViewLayer *view_layer,
+                                            const char *name, int channels, const char *chanid, int UNUSED(type))
+ {
 -      RE_engine_add_pass(engine, name, channels, chanid, srl->name);
++      RE_engine_add_pass(engine, name, channels, chanid, view_layer->name);
+ }
+ static void render_result_create_all_passes(RenderEngine *engine, Render *re, RenderLayer *rl)
+ {
+       if (engine && engine->type->update_render_passes) {
 -              SceneRenderLayer *srl;
 -              srl = BLI_findstring(&re->r.layers, rl->name, offsetof(SceneRenderLayer, name));
 -              if (srl) {
 -                      RE_engine_update_render_passes(engine, re->scene, srl, render_result_register_pass_cb);
++              ViewLayer *view_layer;
++              view_layer = BLI_findstring(&re->view_layers, rl->name, offsetof(ViewLayer, name));
++              if (view_layer) {
++                      RE_engine_update_render_passes(engine, re->scene, view_layer, render_result_register_pass_cb);
+               }
+       }
+ }
  /* begin write of exr tile file */
- void render_result_exr_file_begin(Render *re)
+ void render_result_exr_file_begin(Render *re, RenderEngine *engine)
  {
        RenderResult *rr;
        RenderLayer *rl;