Blender V5.3
node_compositor_job.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2026 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BLI_listbase.hh"
10
11#include "GPU_capabilities.hh"
12
13#include "IMB_imbuf.hh"
14
15#include "BKE_callbacks.hh"
16#include "BKE_compositor.hh"
17#include "BKE_context.hh"
18#include "BKE_global.hh"
19#include "BKE_image.hh"
20#include "BKE_main.hh"
21#include "BKE_scene.hh"
22#include "BKE_scene_runtime.hh"
23
24#include "WM_api.hh"
25#include "WM_types.hh"
26
27#include "DEG_depsgraph.hh"
31
32#include "RE_compositor.hh"
33
34#include "NOD_eval_log.hh"
35
36#include "ED_image.hh"
37#include "ED_node.hh"
38#include "ED_screen.hh"
39
40#include "COM_context.hh"
41
42namespace blender {
43
51 /* Identifies if the compositor is executing due to the user making a modification or if it is
52 * executing due to playback or rendering. */
53 bool triggered_by_user = false;
54};
55
56/* Suspend or resume animation playback if animation is playing. */
57static void set_animation_playback(wmWindowManager *window_manager, const bool enabled)
58{
59 wmWindow *animation_playback_window = ED_window_animation_playing_no_scrub(window_manager);
60 if (animation_playback_window) {
61 bScreen *screen = WM_window_get_active_screen(animation_playback_window);
62 WM_event_timer_sleep(window_manager, animation_playback_window, screen->animtimer, !enabled);
63 }
64}
65
66static void compositor_job_init(void *compositor_job_data)
67{
68 CompositorJob *compositor_job = static_cast<CompositorJob *>(compositor_job_data);
69
70 Main *bmain = compositor_job->bmain;
71 Scene *scene = compositor_job->scene;
72 ViewLayer *view_layer = compositor_job->view_layer;
73
74 bke::CompositorRuntime &compositor_runtime = scene->runtime->compositor;
75
76 if (!compositor_runtime.preview_depsgraph) {
77 compositor_runtime.preview_depsgraph = DEG_graph_new(
78 bmain, scene, view_layer, DAG_EVAL_RENDER);
79 DEG_debug_name_set(compositor_runtime.preview_depsgraph, "COMPOSITOR");
80 }
81
82 /* Update the viewer layer of the compositor if it changed since the depsgraph was created. */
83 if (DEG_get_input_view_layer(compositor_runtime.preview_depsgraph) != view_layer) {
84 DEG_graph_replace_owners(compositor_runtime.preview_depsgraph, bmain, scene, view_layer);
86 }
87
89
90 /* NOTE: Don't update animation to preserve unkeyed changes, this means can not use
91 * evaluate_on_framechange. */
93
94 compositor_job->render = RE_NewInteractiveCompositorRender(scene);
98 }
99
100 /* Suspend animation playback (if any) until the compositor is done to allow frames to be fully
101 * processed. */
102 set_animation_playback(compositor_job->window_manager, false);
103}
104
105static void compositor_job_start(void *compositor_job_data, wmJobWorkerStatus *worker_status)
106{
107 CompositorJob *compositor_job = static_cast<CompositorJob *>(compositor_job_data);
108
109 RE_test_break_cb(compositor_job->render, &worker_status->stop, [](void *should_stop) -> bool {
110 return *static_cast<bool *>(should_stop) || G.is_break;
111 });
112
114 compositor_job->bmain, &compositor_job->scene->id, BKE_CB_EVT_COMPOSITE_PRE);
115
116 bke::CompositorRuntime &compositor_runtime = compositor_job->scene->runtime->compositor;
117 Scene *evaluated_scene = DEG_get_evaluated_scene(compositor_runtime.preview_depsgraph);
118 render::CompositorInputData input_data(*compositor_job->render,
119 *compositor_job->bmain,
120 *evaluated_scene,
121 evaluated_scene->r,
122 "",
123 nullptr,
124 compositor_job->needed_side_effect_outputs,
125 compositor_job->triggered_by_user);
126 if (!(evaluated_scene->r.scemode & R_MULTIVIEW)) {
127 RE_compositor_execute(input_data);
128 }
129 else {
130 for (SceneRenderView &scene_render_view : evaluated_scene->r.views) {
131 if (!BKE_scene_multiview_is_render_view_active(&evaluated_scene->r, &scene_render_view)) {
132 continue;
133 }
134 input_data.view_name = scene_render_view.name;
135 RE_compositor_execute(input_data);
136 }
137 }
138}
139
140static void compositor_job_complete(void *compositor_job_data)
141{
142 CompositorJob *compositor_job = static_cast<CompositorJob *>(compositor_job_data);
143
144 Scene *scene = compositor_job->scene;
145 BKE_callback_exec_id(compositor_job->bmain, &scene->id, BKE_CB_EVT_COMPOSITE_POST);
146
148 scene->runtime->compositor.nodes_evaluation_log = std::move(
149 evaluated_scene->runtime->compositor.nodes_evaluation_log);
150
152
153 /* Resume animation playback (if any) after the compositor is done. */
154 set_animation_playback(compositor_job->window_manager, true);
155}
156
157static void compositor_job_cancel(void *compositor_job_data)
158{
159 CompositorJob *compositor_job = static_cast<CompositorJob *>(compositor_job_data);
160
161 Scene *scene = compositor_job->scene;
162 BKE_callback_exec_id(compositor_job->bmain, &scene->id, BKE_CB_EVT_COMPOSITE_CANCEL);
163
164 /* Resume animation playback (if any) after the compositor is done. */
165 set_animation_playback(compositor_job->window_manager, true);
166}
167
168static void compositor_job_free(void *compositor_job_data)
169{
170 MEM_delete(static_cast<CompositorJob *>(compositor_job_data));
171}
172
173static bool is_compositing_possible(const Scene *scene)
174{
175 if (G.background) {
176 return false;
177 }
178
179 if (G.is_rendering) {
180 return false;
181 }
182
184 return false;
185 }
186
187 /* CPU compositor can always run. */
189 return true;
190 }
191
192 /* The render size exceeds what can be allocated as a GPU texture. */
193 int width, height;
194 BKE_render_resolution(&scene->r, false, &width, &height);
195 if (width > 8192 || height > 8192) {
196 WM_global_report(RPT_ERROR, "Render size too large for GPU, use CPU compositor instead");
197 return false;
198 }
199
200 return true;
201}
202
203/* Returns the compositor outputs that need to be computed because their result is visible to the
204 * user or required by the render pipeline. */
206 const wmWindowManager *window_manager)
207{
208 if (G.background) {
210 }
211
212 compositor::SideEffectOutputTypes needed_side_effect_outputs =
214
215 for (wmWindow &window : window_manager->windows) {
216 bScreen *screen = WM_window_get_active_screen(&window);
217 for (ScrArea &area : screen->areabase) {
218 SpaceLink *space_link = area.spacedata.first();
219 if (!space_link || !ELEM(space_link->spacetype, SPACE_NODE, SPACE_IMAGE)) {
220 continue;
221 }
222 if (space_link->spacetype == SPACE_NODE) {
223 const SpaceNode *space_node = reinterpret_cast<const SpaceNode *>(space_link);
224 if (space_node->flag & SNODE_BACKDRAW) {
225 needed_side_effect_outputs |= compositor::SideEffectOutputTypes::ViewerNode;
226 }
227 if (space_node->overlay.flag & SN_OVERLAY_SHOW_PREVIEWS) {
228 needed_side_effect_outputs |= compositor::SideEffectOutputTypes::NodePreviews;
229 }
230 }
231 else if (space_link->spacetype == SPACE_IMAGE) {
232 const SpaceImage *space_image = reinterpret_cast<const SpaceImage *>(space_link);
233 Image *image = ED_space_image(space_image);
234 if (image && image->source == IMA_SRC_VIEWER && image->type == IMA_TYPE_COMPOSITE) {
235 needed_side_effect_outputs |= compositor::SideEffectOutputTypes::ViewerNode;
236 }
237 }
238
239 /* All possible outputs are already needed, return early. */
240 if (needed_side_effect_outputs == (compositor::SideEffectOutputTypes::ViewerNode |
242 {
243 return needed_side_effect_outputs;
244 }
245 }
246 }
247
248 /* None of the outputs are needed except node previews but they are a secondary output that needs
249 * another output to be computed with, so this is practically none. */
250 if (needed_side_effect_outputs == compositor::SideEffectOutputTypes::NodePreviews) {
252 }
253
254 return needed_side_effect_outputs;
255}
256
257static eWM_JobFlag get_job_flags(const bool triggered_by_user)
258{
259 /* Of the job is triggered by the user, report progress. */
260 if (triggered_by_user) {
262 }
263
264 return WM_JOB_EXCL_RENDER;
265}
266
268 Scene *scene,
269 ViewLayer *view_layer,
270 const bool triggered_by_user)
271{
272 /* Avoid displaying stale warnings/errors of the previously assigned node group. */
274
275 if (!is_compositing_possible(scene)) {
276 return;
277 }
278
279 wmWindowManager *window_manager = bmain->wm.first();
280 const compositor::SideEffectOutputTypes needed_side_effect_outputs =
281 get_needed_side_effect_outputs(window_manager);
282 if (needed_side_effect_outputs == compositor::SideEffectOutputTypes::None) {
283 return;
284 }
285
286 Image *render_result_image = BKE_image_ensure_viewer(bmain, IMA_TYPE_R_RESULT, "Render Result");
287 BKE_image_backup_render(scene, render_result_image, false);
288
289 wmWindow *window = window_manager->runtime->winactive ? window_manager->runtime->winactive :
290 window_manager->windows.first();
291 wmJob *job = WM_jobs_get(window_manager,
292 window,
293 scene,
294 "Compositing...",
295 get_job_flags(triggered_by_user),
297
298 CompositorJob *compositor_job = MEM_new<CompositorJob>("Compositor Job");
299 compositor_job->window_manager = window_manager;
300 compositor_job->bmain = bmain;
301 compositor_job->scene = scene;
302 compositor_job->view_layer = view_layer;
303 compositor_job->needed_side_effect_outputs = needed_side_effect_outputs;
304 compositor_job->triggered_by_user = triggered_by_user;
305
306 WM_jobs_customdata_set(job, compositor_job, compositor_job_free);
307 WM_jobs_timer(job, 0.1, 0, 0);
311 nullptr,
312 nullptr,
315
316 G.is_break = false;
317 WM_jobs_start(window_manager, job);
318}
319
320} // namespace blender
#define ND_COMPO_RESULT
Definition WM_types.hh:466
#define NC_SCENE
Definition WM_types.hh:391
#define ELEM(...)
std::unique_ptr< nodes::eval_log::NodesEvalLog > nodes_evaluation_log
bool is_enabled(const Scene &scene, ExecutionMode mode)
BMesh Iterators.
bool BKE_scene_multiview_is_render_view_active(const RenderData *rd, const SceneRenderView *srv)
Definition scene.cc:3241
void WM_main_add_notifier(uint type, void *reference)
void DEG_graph_tag_relations_update(Depsgraph *graph)
void WM_event_timer_sleep(wmWindowManager *wm, wmWindow *, wmTimer *timer, bool do_sleep)
static void set_animation_playback(wmWindowManager *window_manager, const bool enabled)
static void compositor_job_cancel(void *compositor_job_data)
@ BKE_CB_EVT_COMPOSITE_CANCEL
@ BKE_CB_EVT_COMPOSITE_PRE
@ BKE_CB_EVT_COMPOSITE_POST
void RE_test_break_cb(Render *re, void *handle, bool(*f)(void *handle))
static void compositor_job_free(void *compositor_job_data)
@ WM_JOB_TYPE_COMPOSITE
Definition WM_api.hh:2010
void IMB_ensure_gpu_context()
Definition module.cc:42
Render * RE_NewInteractiveCompositorRender(const Scene *scene)
Depsgraph * DEG_graph_new(Main *bmain, Scene *scene, ViewLayer *view_layer, eEvaluationMode mode)
Definition depsgraph.cc:279
void BKE_callback_exec_id(Main *bmain, ID *id, eCbEvent evt)
Definition callbacks.cc:45
void WM_jobs_customdata_set(wmJob *wm_job, void *customdata, void(*free)(void *customdata))
Definition wm_jobs.cc:377
@ WM_JOB_EXCL_RENDER
Definition WM_api.hh:1995
@ WM_JOB_PROGRESS
Definition WM_api.hh:1997
void DEG_evaluate_on_refresh(Depsgraph *graph, DepsgraphEvaluateSyncWriteback sync_writeback=DEG_EVALUATE_SYNC_WRITEBACK_NO)
void BKE_render_resolution(const RenderData *r, const bool use_crop, int *r_width, int *r_height)
Definition scene.cc:3168
void WM_jobs_start(wmWindowManager *wm, wmJob *wm_job)
Definition wm_jobs.cc:498
Global G
Definition blender.cc:57
void WM_jobs_callbacks_ex(wmJob *wm_job, wm_jobs_start_callback startjob, void(*initjob)(void *), void(*update)(void *), void(*endjob)(void *), void(*completed)(void *), void(*canceled)(void *))
Definition wm_jobs.cc:416
ViewLayer * DEG_get_input_view_layer(const Depsgraph *graph)
void ED_node_compositor_job(Main *bmain, Scene *scene, ViewLayer *view_layer, bool triggered_by_user)
@ SCE_COMPOSITOR_DEVICE_GPU
void DEG_graph_replace_owners(Depsgraph *depsgraph, Main *bmain, Scene *scene, ViewLayer *view_layer)
Definition depsgraph.cc:286
void RE_display_ensure_gpu_context(Render *re)
static void compositor_job_start(void *compositor_job_data, wmJobWorkerStatus *worker_status)
void DEG_debug_name_set(Depsgraph *depsgraph, const char *name)
void WM_global_report(eReportType type, const char *message)
static compositor::SideEffectOutputTypes get_needed_side_effect_outputs(const wmWindowManager *window_manager)
static eWM_JobFlag get_job_flags(const bool triggered_by_user)
void DEG_graph_build_for_compositor_preview(Depsgraph *graph)
static bool is_compositing_possible(const Scene *scene)
void BKE_image_backup_render(Scene *scene, Image *ima, bool free_current_slot)
void RE_compositor_execute(const render::CompositorInputData input_data)
static void compositor_job_complete(void *compositor_job_data)
wmJob * WM_jobs_get(wmWindowManager *wm, wmWindow *win, const void *owner, const char *name, const eWM_JobFlag flag, const eWM_JobType job_type)
Definition wm_jobs.cc:228
Image * BKE_image_ensure_viewer(Main *bmain, int type, const char *name)
wmWindow * ED_window_animation_playing_no_scrub(const wmWindowManager *wm)
Scene * DEG_get_evaluated_scene(const Depsgraph *graph)
bScreen * WM_window_get_active_screen(const wmWindow *win)
void WM_jobs_timer(wmJob *wm_job, double time_step, uint note, uint endnote, void(*timer_step)(void *))
Definition wm_jobs.cc:393
Image * ED_space_image(const SpaceImage *sima)
Definition image_edit.cc:43
static void compositor_job_init(void *compositor_job_data)
@ SN_OVERLAY_SHOW_PREVIEWS
compositor::SideEffectOutputTypes needed_side_effect_outputs
wmWindowManager * window_manager
ListBaseT< wmWindowManager > wm
Definition BKE_main.hh:415
ListBaseT< SceneRenderView > views
eCompositorDevice compositor_device
bke::SceneRuntime * runtime
struct RenderData r
ListBaseT< SpaceLink > spacedata
eSpaceNodeOverlay_Flag flag
SpaceNodeOverlay overlay
eSpaceNode_Flag flag
struct wmTimer * animtimer
ListBaseT< struct ScrArea > areabase
bke::WindowManagerRuntime * runtime