Blender V5.3
RE_pipeline.h
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2006 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#pragma once
10
11#include "DNA_ID.h"
12#include "DNA_listBase.h"
13#include "DNA_vec_types.h"
14
15class GHOST_IContext;
16
17namespace blender {
18
19namespace bke {
20class BlenderProject;
21}
22
23struct ExrReadHandle;
24struct ImBuf;
25struct Image;
26struct ImageFormatData;
27struct MovieWriter;
28struct Main;
29struct Object;
30struct RenderData;
31struct RenderResult;
32struct ReportList;
33struct Scene;
34struct StampData;
35struct ViewLayer;
36
37/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
38/* this include is what is exposed of render to outside world */
39/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
40
41/* length of the scene name + passname */
42#define RE_MAXNAME ((MAX_ID_NAME - 2) + 10)
43
44/* only used as handle */
45struct RenderView {
46 struct RenderView *next, *prev;
47 char name[/*EXR_VIEW_MAXNAME*/ 64];
48
54 struct ImBuf *ibuf;
55};
56
57struct RenderPass {
58 struct RenderPass *next, *prev;
60 char name[/*EXR_PASS_MAXNAME*/ 64];
61 char chan_id[/*EXR_PASS_MAXCHAN*/ 24];
62
72 struct ImBuf *ibuf;
73
75
76 char fullname[/*EXR_PASS_MAXNAME*/ 64];
77 char view[/*EXR_VIEW_MAXNAME*/ 64];
80
81 char _pad0[4];
82};
83
92
96
98
99 ListBaseT<RenderPass> passes;
100};
101
103 struct RenderResult *next = nullptr, *prev = nullptr;
104
105 /* The number of users of this render result. Default value is 0. The result is freed when
106 * #RE_FreeRenderResult is called with the render result with 0 users. In a way this is
107 * off-by-one, but it is the easiest for the currently used zero-initialized state. The way to
108 * think of it is the number of extra users.
109 *
110 * TODO: Make it an actual number of users, so the #RE_FreeRenderResult frees the result when
111 * the number of users goes to 0.
112 *
113 * TODO: Make it atomic. Currently it is not to allow shallow copying. */
115
116 /* target image size */
117 int rectx = 0, recty = 0;
118
119 /* The temporary storage to pass image data from #RE_AcquireResultImage.
120 * Is null pointer when the RenderResult is not coming from the #RE_AcquireResultImage, and is
121 * a pointer to an existing ibuf in either RenderView or a RenderPass otherwise. */
122 struct ImBuf *ibuf = nullptr;
123
124 /* coordinates within final image (after cropping) */
126
127 /* the main buffers */
128 ListBaseT<RenderLayer> layers = {};
129
130 /* multiView maps to a StringVector in OpenEXR */
131 ListBaseT<RenderView> views = {};
132
133 /* Render layer to display. */
134 RenderLayer *renlay = nullptr;
135
136 /* for render results in Image, verify validity for sequences */
137 int framenr = 0;
138
145 double ppm[2];
146
147 /* for acquire image, to indicate if it there is a combined layer */
148 bool have_combined = false;
149
150 /* render info text */
151 char *text = nullptr;
152 char *error = nullptr;
153
154 struct StampData *stamp_data = nullptr;
155
156 bool passes_allocated = false;
157};
158
167
168/* *********************** API ******************** */
169
175struct Render *RE_NewRender(const void *owner);
176struct Render *RE_GetRender(const void *owner);
177
178struct Scene;
179struct Render *RE_NewSceneRender(const struct Scene *scene);
180struct Render *RE_GetSceneRender(const struct Scene *scene);
181
182struct RenderEngineType;
183struct ViewRender *RE_NewViewRender(struct RenderEngineType *engine_type);
184
185/* Creates a new render for interactive compositing of the given scene. If an existing render
186 * exists for the given scene, it is returned instead. See interactive_compositor_renders in
187 * RenderGlobal for more information. */
188struct Render *RE_NewInteractiveCompositorRender(const struct Scene *scene);
189
190/* Assign default dummy callbacks. */
191
197void RE_FreeRender(struct Render *re);
198void RE_FreeViewRender(struct ViewRender *view_render);
202void RE_FreeAllRender();
203
208
213
222void RE_FreePersistentData(const struct Scene *scene);
223
228
234
238void RE_FreeRenderResult(struct RenderResult *rr);
242struct RenderResult *RE_AcquireResultRead(struct Render *re);
243struct RenderResult *RE_AcquireResultWrite(struct Render *re);
245void RE_ReleaseResult(struct Render *re);
251void RE_AcquireResultImageViews(struct Render *re, struct RenderResult *rr);
255void RE_ReleaseResultImageViews(struct Render *re, struct RenderResult *rr);
256
262void RE_AcquireResultImage(struct Render *re, struct RenderResult *rr, int view_id);
263void RE_ReleaseResultImage(struct Render *re);
264void RE_SwapResult(struct Render *re, struct RenderResult **rr);
265void RE_ClearResult(struct Render *re);
266struct RenderStats *RE_GetStats(struct Render *re);
267
271void RE_ResultGet32(Render *re, uint8_t *dst);
272
273bool RE_ResultIsMultiView(struct RenderResult *rr);
274
275void RE_render_result_full_channel_name(char *fullname,
276 const char *layname,
277 const char *passname,
278 const char *viewname,
279 const char *chan_id,
280 int channel);
281
283 const struct ImageFormatData *imf,
284 const float dither,
285 int view_id);
287 const struct ImBuf *ibuf,
288 int view_id);
289
290struct RenderLayer *RE_GetRenderLayer(struct RenderResult *rr, const char *name);
291float *RE_RenderLayerGetPass(struct RenderLayer *rl, const char *name, const char *viewname);
293 const char *name,
294 const char *viewname);
295
296bool RE_HasSingleLayer(struct Render *re);
297
302struct RenderPass *RE_create_gp_pass(struct RenderResult *rr,
303 const char *layername,
304 const char *viewname);
305
306void RE_create_render_pass(struct RenderResult *rr,
307 const char *name,
308 int channels,
309 const char *chan_id,
310 const char *layername,
311 const char *viewname,
312 bool allocate);
313
318void RE_InitState(struct Render *re,
319 struct Render *source,
320 const struct RenderData *rd,
321 ListBaseT<ViewLayer> *render_layers,
322 struct ViewLayer *single_layer,
323 int winx,
324 int winy,
325 const rcti *disprect);
326
332struct Object *RE_GetCamera(struct Render *re);
333void RE_SetOverrideCamera(struct Render *re, struct Object *cam_ob);
339void RE_SetCamera(struct Render *re, const struct Object *cam_ob);
340
344void RE_GetViewPlane(struct Render *re, rctf *r_viewplane, rcti *r_disprect);
345
350
352 struct RenderResult *rr,
354 struct Scene *scene,
355 const struct RenderData *rd,
356 struct MovieWriter **movie_writers,
357 int totvideos,
358 bool preview);
359
369void RE_RenderFrame(struct Render *re,
370 struct Main *bmain,
371 struct Scene *scene,
372 struct ViewLayer *single_layer,
373 struct Object *camera_override,
374 int frame,
375 float subframe,
376 bool write_still);
380void RE_RenderAnim(struct Render *re,
381 struct Main *bmain,
382 struct Scene *scene,
383 struct ViewLayer *single_layer,
384 struct Object *camera_override,
385 int sfra,
386 int efra,
387 int tfra);
388#ifdef WITH_FREESTYLE
389void RE_RenderFreestyleStrokes(struct Render *re,
390 struct Main *bmain,
391 struct Scene *scene,
392 bool render);
393void RE_RenderFreestyleExternal(struct Render *re);
394#endif
395
396void RE_SetActiveRenderView(struct Render *re, const char *viewname);
397const char *RE_GetActiveRenderView(struct Render *re);
398
402void RE_SetReports(struct Render *re, struct ReportList *reports);
403
407void RE_PreviewRender(struct Render *re, struct Main *bmain, struct Scene *scene);
408
412bool RE_ReadRenderResult(struct Scene *scene, struct Scene *scenode);
413
415 ExrReadHandle *exrhandle, const char *colorspace, bool predivide, int rectx, int recty);
416
417/*
418 * Display, event callbacks and GPU contexts
419 */
420
421void RE_display_init(Render *re);
423void RE_display_share(Render *re, const Render *parent_re);
424void RE_display_free(Render *re);
425
426void RE_display_update_cb(struct Render *re,
427 void *handle,
428 void (*f)(void *handle, RenderResult *rr));
429void RE_stats_draw_cb(struct Render *re, void *handle, void (*f)(void *handle, RenderStats *rs));
430void RE_progress_cb(struct Render *re, void *handle, void (*f)(void *handle, float));
431void RE_draw_lock_cb(struct Render *re, void *handle, void (*f)(void *handle, bool lock));
432void RE_test_break_cb(struct Render *re, void *handle, bool (*f)(void *handle));
433void RE_prepare_viewlayer_cb(struct Render *re,
434 void *handle,
435 bool (*f)(void *handle, ViewLayer *vl, struct Depsgraph *depsgraph));
436void RE_current_scene_update_cb(struct Render *re,
437 void *handle,
438 void (*f)(void *handle, struct Scene *scene));
439
442
443bool RE_seq_render_active(struct Scene *scene, const struct RenderData *rd);
444
449bool RE_passes_have_name(struct RenderLayer *rl);
450
452 const char *name,
453 const char *viewname);
454
460void RE_pass_set_buffer_data(struct RenderPass *pass, float *data);
461
462void RE_GetCameraWindow(struct Render *re, const struct Object *camera, float r_winmat[4][4]);
466void RE_GetCameraWindowWithOverscan(const struct Render *re, float overscan, float r_winmat[4][4]);
467void RE_GetCameraModelMatrix(const struct Render *re,
468 const struct Object *camera,
469 float r_modelmat[4][4]);
470
471void RE_GetWindowMatrixWithOverscan(bool is_ortho,
472 float clip_start,
473 float clip_end,
474 rctf viewplane,
475 float overscan,
476 float r_winmat[4][4]);
477
478struct Scene *RE_GetScene(struct Render *re);
479void RE_SetScene(struct Render *re, struct Scene *sce);
480
481/* When rendering an animation, saving files is required, either through scene saving or through
482 * a compositor File Output node. */
483bool RE_disable_save_output_allowed(const bool is_animation, Scene &scene, ReportList *reports);
484
485bool RE_is_rendering_allowed(const Main &bmain,
486 struct Scene *scene,
487 struct ViewLayer *single_layer,
488 struct Object *camera_override,
489 struct ReportList *reports);
490
492
493/******* defined in `render_result.cc` *********/
494
498struct RenderView *RE_RenderViewGetById(struct RenderResult *rr, int view_id);
499struct RenderView *RE_RenderViewGetByName(struct RenderResult *rr, const char *viewname);
500
502
503struct ImBuf *RE_RenderPassEnsureImBuf(RenderPass *render_pass);
504struct ImBuf *RE_RenderViewEnsureImBuf(const RenderResult *render_result, RenderView *render_view);
505
506/* Returns true if the pass is a color (as opposite of data) and needs to be color managed. */
507bool RE_RenderPassIsColor(const RenderPass *render_pass);
508
509} // namespace blender
ID and Library types, which are fundamental for SDNA.
#define MAX_ID_NAME
Definition DNA_ID.h:367
These structs are the foundation for all linked lists in the library system.
#define RE_MAXNAME
Definition RE_pipeline.h:42
volatile int lock
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
BMesh Iterators.
void * RE_blender_gpu_context_ensure(Render *re)
void RE_SetActiveRenderView(Render *re, const char *viewname)
Render * RE_GetRender(const void *owner)
void RE_RenderFrame(Render *re, Main *bmain, Scene *scene, ViewLayer *single_layer, Object *camera_override, const int frame, const float subframe, const bool write_still)
RenderPass * RE_create_gp_pass(RenderResult *rr, const char *layername, const char *viewname)
RenderView * RE_RenderViewGetById(RenderResult *rr, const int view_id)
bool RE_seq_render_active(Scene *scene, const RenderData *rd)
void RE_SetReports(Render *re, ReportList *reports)
void RE_SetOverrideCamera(Render *re, Object *cam_ob)
Definition initrender.cc:37
void RE_ResultGet32(Render *re, uint8_t *dst)
bool RE_HasCombinedLayer(const RenderResult *result)
void RE_stats_draw_cb(Render *re, void *handle, void(*f)(void *handle, RenderStats *rs))
void RE_test_break_cb(Render *re, void *handle, bool(*f)(void *handle))
void RE_render_result_full_channel_name(char *fullname, const char *layname, const char *passname, const char *viewname, const char *chan_id, const int channel)
bool RE_layers_have_name(RenderResult *result)
void RE_render_result_rect_from_ibuf(RenderResult *rr, const ImBuf *ibuf, const int view_id)
RenderLayer * RE_GetRenderLayer(RenderResult *rr, const char *name)
void RE_SwapResult(Render *re, RenderResult **rr)
Render * RE_NewInteractiveCompositorRender(const Scene *scene)
void RE_SetScene(Render *re, Scene *sce)
void RE_GetCameraWindow(Render *re, const Object *camera, float r_winmat[4][4])
Definition initrender.cc:62
ImBuf * RE_RenderLayerGetPassImBuf(RenderLayer *rl, const char *name, const char *viewname)
void RE_FreePersistentData(const Scene *scene)
void RE_prepare_viewlayer_cb(Render *re, void *handle, bool(*f)(void *handle, ViewLayer *vl, Depsgraph *depsgraph))
Render * RE_NewRender(const void *owner)
bool RE_allow_render_generic_object(Object *ob)
ImBuf * RE_render_result_rect_to_ibuf(RenderResult *rr, const ImageFormatData *imf, const float dither, const int view_id)
bool RE_RenderResult_is_stereo(const RenderResult *result)
void RE_FreeRenderResult(RenderResult *rr)
void RE_current_scene_update_cb(Render *re, void *handle, void(*f)(void *handle, Scene *scene))
const char * RE_GetActiveRenderView(Render *re)
Render * RE_GetSceneRender(const Scene *scene)
void RE_progress_cb(Render *re, void *handle, void(*f)(void *handle, float))
void RE_GetWindowMatrixWithOverscan(bool is_ortho, float clip_start, float clip_end, rctf viewplane, float overscan, float r_winmat[4][4])
Definition initrender.cc:79
void RE_GetCameraModelMatrix(const Render *re, const Object *camera, float r_modelmat[4][4])
Definition initrender.cc:74
RenderResult * RE_AcquireResultWrite(Render *re)
BMesh const char void * data
bool RE_WriteRenderViewsMovie(ReportList *reports, RenderResult *rr, const bke::BlenderProject *project, Scene *scene, const RenderData *rd, MovieWriter **movie_writers, const int totvideos, bool preview)
unsigned char uint8_t
Definition BKE_text.h:79
bool RE_ResultIsMultiView(RenderResult *rr)
void RE_display_ensure_gpu_context(Render *re)
bool RE_RenderPassIsColor(const RenderPass *render_pass)
float * RE_RenderLayerGetPass(RenderLayer *rl, const char *name, const char *viewname)
RenderResult * RE_MultilayerConvert(ExrReadHandle *exrhandle, const char *colorspace, bool predivide, int rectx, int recty)
void RE_pass_set_buffer_data(RenderPass *pass, float *data)
bool RE_is_rendering_allowed(const Main &bmain, Scene *scene, ViewLayer *single_layer, Object *camera_override, ReportList *reports)
void RE_display_share(Render *re, const Render *parent_re)
ImBuf * RE_RenderPassEnsureImBuf(RenderPass *render_pass)
bool RE_HasFloatPixels(const RenderResult *result)
RenderResult * RE_AcquireResultRead(Render *re)
RenderPass * RE_pass_find_by_name(RenderLayer *rl, const char *name, const char *viewname)
void RE_InitState(Render *re, Render *source, const RenderData *rd, ListBaseT< ViewLayer > *, ViewLayer *single_layer, int winx, int winy, const rcti *disprect)
bool RE_passes_have_name(RenderLayer *rl)
void RE_display_update_cb(Render *re, void *handle, void(*f)(void *handle, RenderResult *rr))
void RE_draw_lock_cb(Render *re, void *handle, void(*f)(void *handle, bool lock))
Render * RE_NewSceneRender(const Scene *scene)
void RE_RenderAnim(Render *re, Main *bmain, Scene *scene, ViewLayer *single_layer, Object *camera_override, int sfra, int efra, int tfra)
bool RE_disable_save_output_allowed(const bool is_animation, Scene &scene, ReportList *reports)
ViewRender * RE_NewViewRender(RenderEngineType *engine_type)
void RE_create_render_pass(RenderResult *rr, const char *name, int channels, const char *chan_id, const char *layername, const char *viewname, const bool allocate)
RenderStats * RE_GetStats(Render *re)
RenderView * RE_RenderViewGetByName(RenderResult *rr, const char *viewname)
void RE_GetViewPlane(Render *re, rctf *r_viewplane, rcti *r_disprect)
void RE_PreviewRender(Render *re, Main *bmain, Scene *sce)
ImBuf * RE_RenderViewEnsureImBuf(const RenderResult *render_result, RenderView *render_view)
void RE_AcquireResultImageViews(Render *re, RenderResult *rr)
void RE_SetCamera(Render *re, const Object *cam_ob)
Definition initrender.cc:42
void RE_ReferenceRenderResult(RenderResult *rr)
bool RE_ReadRenderResult(Scene *scene, Scene *scenode)
RenderResult * RE_DuplicateRenderResult(RenderResult *rr)
void RE_ReleaseResultImageViews(Render *re, RenderResult *rr)
void RE_GetCameraWindowWithOverscan(const Render *re, float overscan, float r_winmat[4][4])
Definition initrender.cc:68
GHOST_IContext * RE_system_gpu_context_get(Render *re)
void RE_FreeViewRender(ViewRender *view_render)
void RE_AcquireResultImage(Render *re, RenderResult *rr, const int view_id)
Object * RE_GetCamera(Render *re)
Definition initrender.cc:31
ListBaseT< RenderPass > passes
Definition RE_pipeline.h:99
struct RenderLayer * next
Definition RE_pipeline.h:91
char name[RE_MAXNAME]
Definition RE_pipeline.h:94
struct RenderLayer * prev
Definition RE_pipeline.h:91
struct RenderPass * prev
Definition RE_pipeline.h:58
struct RenderPass * next
Definition RE_pipeline.h:58
struct ImBuf * ibuf
Definition RE_pipeline.h:72
struct RenderResult * prev
struct StampData * stamp_data
struct RenderResult * next
ListBaseT< RenderView > views
ListBaseT< RenderLayer > layers
struct ImBuf * ibuf
RenderLayer * renlay
char scene_name[MAX_ID_NAME - 2]
const char * statstr
const char * infostr
struct ImBuf * ibuf
Definition RE_pipeline.h:54
struct RenderView * next
Definition RE_pipeline.h:46
struct RenderView * prev
Definition RE_pipeline.h:46