Blender V5.3
render_result.cc
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#include <cerrno>
10#include <cstdio>
11#include <cstdlib>
12#include <cstring>
13
14#include "MEM_guardedalloc.h"
15
16#include "BLI_hash_md5.hh"
17#include "BLI_listbase.hh"
18#include "BLI_path_utils.hh"
19#include "BLI_rect.hh"
20#include "BLI_string_utf8.hh"
21#include "BLI_string_utils.hh"
22#include "BLI_utildefines.hh"
23#include "BLI_vector_set.hh"
24
25#include "DNA_layer_types.h"
26#include "DNA_userdef_types.h"
27
28#include "BKE_appdir.hh"
29#include "BKE_image.hh"
30#include "BKE_image_format.hh"
31#include "BKE_image_save.hh"
32#include "BKE_main.hh"
33#include "BKE_report.hh"
34#include "BKE_scene.hh"
35
37#include "IMB_imbuf.hh"
38#include "IMB_imbuf_types.hh"
39#include "IMB_openexr.hh"
40#include "IMB_partial_update.hh"
41
42#include "render_result.h"
43#include "render_types.h"
44
45namespace blender {
46
47/* -------------------------------------------------------------------- */
50
52{
53 while (rr->views.first()) {
54 RenderView *rv = rr->views.first();
55 BLI_remlink(&rr->views, rv);
56
58
59 MEM_delete(rv);
60 }
61
62 rr->have_combined = false;
63}
64
66{
67 if (rr == nullptr) {
68 return;
69 }
70
71 /* Only actually free when RenderResult when the render result has zero users which is its
72 * default state.
73 * There is no need to lock as the user-counted render results are protected by mutex at the
74 * higher call stack level. */
75 if (rr->user_counter > 0) {
76 --rr->user_counter;
77 return;
78 }
79
80 while (rr->layers.first()) {
81 RenderLayer *rl = rr->layers.first();
82
83 while (rl->passes.first()) {
84 RenderPass *rpass = rl->passes.first();
85
86 IMB_freeImBuf(rpass->ibuf);
87
88 BLI_freelinkN(&rl->passes, rpass);
89 }
90 BLI_remlink(&rr->layers, rl);
91 MEM_delete(rl);
92 }
93
95
97
98 if (rr->text) {
99 MEM_delete(rr->text);
100 }
101 if (rr->error) {
102 MEM_delete(rr->error);
103 }
104
106
107 MEM_delete(rr);
108}
109
110void render_result_free_list(ListBaseT<RenderResult> *lb, RenderResult *rr)
111{
112 RenderResult *rrnext;
113
114 for (; rr; rr = rrnext) {
115 rrnext = rr->next;
116
117 if (lb && lb->first_) {
118 BLI_remlink(lb, rr);
119 }
120
122 }
123}
124
126{
127 for (RenderLayer &rl : rr->layers) {
128 for (RenderPass &rpass : rl.passes) {
130 }
131 }
132}
133
135
136/* -------------------------------------------------------------------- */
139
141{
142 if (dst == nullptr || src == nullptr) {
143 return;
144 }
145
146 for (RenderView &rview : src->views) {
147 RenderView *rv;
148
149 rv = MEM_new<RenderView>("new render view");
150 BLI_addtail(&dst->views, rv);
151
152 STRNCPY_UTF8(rv->name, rview.name);
153
154 rv->ibuf = rview.ibuf;
155 }
156}
157
159{
160 if (rr == nullptr) {
161 return;
162 }
163
164 while (rr->views.first()) {
165 RenderView *rv = rr->views.first();
166 BLI_remlink(&rr->views, rv);
167 MEM_delete(rv);
168 }
169}
170
172
173/* -------------------------------------------------------------------- */
176
178{
179 if (RE_RenderPassIsColor(&render_pass)) {
180 return;
181 }
182
184 IMB_colormanagement_assign_float_colorspace(render_pass.ibuf, data_colorspace);
185}
186
188{
189 if (rp->ibuf && rp->ibuf->float_data()) {
190 return;
191 }
192
193 /* NOTE: In-lined manual allocation to support floating point buffers of an arbitrary number of
194 * channels. */
195
196 const size_t rectsize = size_t(rr->rectx) * rr->recty * rp->channels;
197 float *buffer_data = MEM_new_array_zeroed<float>(rectsize, rp->name);
198
201 rp->ibuf->channels = rp->channels;
202 copy_v2_v2_db(rp->ibuf->ppm, rr->ppm);
203 rp->ibuf->assign_float_data(buffer_data);
205
206 if (STREQ(rp->name, RE_PASSNAME_VECTOR)) {
207 /* initialize to max speed */
208 for (int x = rectsize - 1; x >= 0; x--) {
209 buffer_data[x] = PASS_VECTOR_MAX;
210 }
211 }
212 else if (STREQ(rp->name, RE_PASSNAME_DEPTH)) {
213 for (int x = rectsize - 1; x >= 0; x--) {
214 buffer_data[x] = 1e10f;
215 }
216 }
217}
218
220 RenderLayer *rl,
221 int channels,
222 const char *name,
223 const char *viewname,
224 const char *chan_id,
225 const bool allocate)
226{
227 const int view_id = BLI_findstringindex(&rr->views, viewname, offsetof(RenderView, name));
228 RenderPass *rpass = MEM_new<RenderPass>(name);
229
230 rpass->channels = channels;
231 rpass->rectx = rl->rectx;
232 rpass->recty = rl->recty;
233 rpass->view_id = view_id;
234
235 STRNCPY(rpass->name, name);
236 STRNCPY(rpass->chan_id, chan_id);
237 STRNCPY(rpass->view, viewname);
239 rpass->fullname, nullptr, rpass->name, rpass->view, rpass->chan_id, -1);
240
241 BLI_addtail(&rl->passes, rpass);
242
243 if (allocate) {
245 }
246 else {
247 /* The result contains non-allocated pass now, so tag it as such. */
248 rr->passes_allocated = false;
249 }
250
251 return rpass;
252}
253
255 const rcti *partrct,
256 const char *layername,
257 const char *viewname)
258{
259 RenderResult *rr;
260 RenderLayer *rl;
261 int rectx, recty;
262
263 rectx = BLI_rcti_size_x(partrct);
264 recty = BLI_rcti_size_y(partrct);
265
266 if (rectx <= 0 || recty <= 0) {
267 return nullptr;
268 }
269
270 rr = MEM_new<RenderResult>("new render result");
271 rr->rectx = rectx;
272 rr->recty = recty;
273
274 BKE_scene_ppm_get(&re->r, rr->ppm);
275
276 /* tilerect is relative coordinates within render disprect. do not subtract crop yet */
277 rr->tilerect.xmin = partrct->xmin - re->disprect.xmin;
278 rr->tilerect.xmax = partrct->xmax - re->disprect.xmin;
279 rr->tilerect.ymin = partrct->ymin - re->disprect.ymin;
280 rr->tilerect.ymax = partrct->ymax - re->disprect.ymin;
281
282 rr->passes_allocated = false;
283
284 render_result_views_new(rr, &re->r);
285
286 /* Check render-data for amount of layers. */
287 FOREACH_VIEW_LAYER_TO_RENDER_BEGIN (re, view_layer) {
288 if (layername && layername[0]) {
289 if (!STREQ(view_layer->name, layername)) {
290 continue;
291 }
292 }
293
294 rl = MEM_new<RenderLayer>("new render layer");
295 BLI_addtail(&rr->layers, rl);
296
297 STRNCPY_UTF8(rl->name, view_layer->name);
298 rl->layflag = view_layer->layflag;
299
300 rl->passflag = view_layer->passflag;
301
302 rl->rectx = rectx;
303 rl->recty = recty;
304
305 for (RenderView &rv : rr->views) {
306 const char *view = rv.name;
307
308 if (viewname && viewname[0]) {
309 if (!STREQ(view, viewname)) {
310 continue;
311 }
312 }
313
314 /* A render-layer should always have a "Combined" pass. */
315 render_layer_add_pass(rr, rl, 4, "Combined", view, "RGBA", false);
316 }
317 }
319
320 /* Preview-render doesn't do layers, so we make a default one. */
321 if (rr->layers.is_empty() && !(layername && layername[0])) {
322 rl = MEM_new<RenderLayer>("new render layer");
323 BLI_addtail(&rr->layers, rl);
324
325 rl->rectx = rectx;
326 rl->recty = recty;
327
328 for (RenderView &rv : rr->views) {
329 const char *view = rv.name;
330
331 if (viewname && viewname[0]) {
332 if (!STREQ(view, viewname)) {
333 continue;
334 }
335 }
336
337 /* A render-layer should always have a "Combined" pass. */
338 render_layer_add_pass(rr, rl, 4, RE_PASSNAME_COMBINED, view, "RGBA", false);
339 }
340
341 /* NOTE: this has to be in sync with `scene.cc`. */
344
345 re->single_view_layer[0] = '\0';
346 }
347
348 return rr;
349}
350
352{
353 if (rr == nullptr) {
354 /* Happens when the result was not yet allocated for the current scene or slot configuration.
355 */
356 return;
357 }
358
359 for (RenderLayer &rl : rr->layers) {
360 for (RenderPass &rp : rl.passes) {
362 }
363 }
364
365 rr->passes_allocated = true;
366}
367
368void render_result_clone_passes(Render *re, RenderResult *rr, const char *viewname)
369{
370 for (RenderLayer &rl : rr->layers) {
371 RenderLayer *main_rl = RE_GetRenderLayer(re->result, rl.name);
372 if (!main_rl) {
373 continue;
374 }
375
376 for (RenderPass &main_rp : main_rl->passes) {
377 if (viewname && viewname[0] && !STREQ(main_rp.view, viewname)) {
378 continue;
379 }
380
381 /* Compare `fullname` to make sure that the view also is equal. */
382 const RenderPass *rp = static_cast<const RenderPass *>(
383 BLI_findstring(&rl.passes, main_rp.fullname, offsetof(RenderPass, fullname)));
384 if (!rp) {
386 rr, &rl, main_rp.channels, main_rp.name, main_rp.view, main_rp.chan_id, false);
387 }
388 }
389 }
390}
391
393 const char *name,
394 int channels,
395 const char *chan_id,
396 const char *layername,
397 const char *viewname,
398 const bool allocate)
399{
400 for (RenderLayer &rl : rr->layers) {
401 if (layername && layername[0] && !STREQ(rl.name, layername)) {
402 continue;
403 }
404
405 for (RenderView &rv : rr->views) {
406 const char *view = rv.name;
407
408 if (viewname && viewname[0] && !STREQ(view, viewname)) {
409 continue;
410 }
411
412 /* Ensure that the pass doesn't exist yet. */
413 bool pass_exists = false;
414 for (RenderPass &rp : rl.passes) {
415 if (STREQ(rp.name, name) && STREQ(rp.view, view)) {
416 pass_exists = true;
417 break;
418 }
419 }
420
421 if (!pass_exists) {
422 render_layer_add_pass(rr, &rl, channels, name, view, chan_id, allocate);
423 }
424 }
425 }
426}
427
429{
430 ImBuf *ibuf = RE_RenderPassEnsureImBuf(pass);
431
432 ibuf->assign_float_data(data);
434}
435
437 const char *layname,
438 const char *passname,
439 const char *viewname,
440 const char *chan_id,
441 const int channel)
442{
443 /* OpenEXR compatible full channel name. */
444 const char *strings[4];
445 int strings_len = 0;
446
447 if (layname && layname[0]) {
448 strings[strings_len++] = layname;
449 }
450 if (passname && passname[0]) {
451 strings[strings_len++] = passname;
452 }
453 if (viewname && viewname[0]) {
454 strings[strings_len++] = viewname;
455 }
456
457 char token[2];
458 if (channel >= 0) {
459 ARRAY_SET_ITEMS(token, chan_id[channel], '\0');
460 strings[strings_len++] = token;
461 }
462
463 BLI_string_join_array_by_sep_char(fullname, EXR_PASS_MAXNAME, '.', strings, strings_len);
464}
465
466static int passtype_from_name(const char *name)
467{
468 const char delim[] = {'.', '\0'};
469 const char *sep, *suf;
470 int len = BLI_str_partition(name, delim, &sep, &suf);
471
472#define CHECK_PASS(NAME) \
473 if (STREQLEN(name, RE_PASSNAME_##NAME, len)) { \
474 return SCE_PASS_##NAME; \
475 } \
476 ((void)0)
477
478 CHECK_PASS(COMBINED);
479 CHECK_PASS(DEPTH);
482 CHECK_PASS(UV);
483 CHECK_PASS(EMIT);
484 CHECK_PASS(SHADOW);
485 CHECK_PASS(AO);
486 CHECK_PASS(ENVIRONMENT);
487 CHECK_PASS(INDEXOB);
488 CHECK_PASS(INDEXMA);
489 CHECK_PASS(MIST);
490 CHECK_PASS(DIFFUSE_DIRECT);
491 CHECK_PASS(DIFFUSE_INDIRECT);
492 CHECK_PASS(DIFFUSE_COLOR);
493 CHECK_PASS(GLOSSY_DIRECT);
494 CHECK_PASS(GLOSSY_INDIRECT);
495 CHECK_PASS(GLOSSY_COLOR);
496 CHECK_PASS(TRANSM_DIRECT);
497 CHECK_PASS(TRANSM_INDIRECT);
498 CHECK_PASS(TRANSM_COLOR);
499 CHECK_PASS(SUBSURFACE_DIRECT);
500 CHECK_PASS(SUBSURFACE_INDIRECT);
501 CHECK_PASS(SUBSURFACE_COLOR);
502
503#undef CHECK_PASS
504 return 0;
505}
506
507static void render_result_add_view(RenderResult *rr, const char *name)
508{
509 RenderView *rv = MEM_new<RenderView>("new render view");
510 STRNCPY_UTF8(rv->name, name);
511
512 /* For stereo drawing we need to ensure:
513 * STEREO_LEFT_NAME == STEREO_LEFT_ID and
514 * STEREO_RIGHT_NAME == STEREO_RIGHT_ID */
515
516 if (STREQ(name, STEREO_LEFT_NAME)) {
517 BLI_addhead(&rr->views, rv);
518 }
519 else if (STREQ(name, STEREO_RIGHT_NAME)) {
520 RenderView *left_rv = static_cast<RenderView *>(
522
523 if (left_rv == nullptr) {
524 BLI_addhead(&rr->views, rv);
525 }
526 else {
527 BLI_insertlinkafter(&rr->views, left_rv, rv);
528 }
529 }
530 else {
531 BLI_addtail(&rr->views, rv);
532 }
533}
534
535static int order_render_passes(const void *a, const void *b)
536{
537 /* 1 if `a` is after `b`. */
538 const RenderPass *rpa = static_cast<const RenderPass *>(a);
539 const RenderPass *rpb = static_cast<const RenderPass *>(b);
540 uint passtype_a = passtype_from_name(rpa->name);
541 uint passtype_b = passtype_from_name(rpb->name);
542
543 /* Render passes with default type always go first. */
544 if (passtype_b && !passtype_a) {
545 return 1;
546 }
547 if (passtype_a && !passtype_b) {
548 return 0;
549 }
550
551 if (passtype_a && passtype_b) {
552 if (passtype_a > passtype_b) {
553 return 1;
554 }
555 if (passtype_a < passtype_b) {
556 return 0;
557 }
558 }
559 else {
560 int cmp = strncmp(rpa->name, rpb->name, EXR_PASS_MAXNAME);
561 if (cmp > 0) {
562 return 1;
563 }
564 if (cmp < 0) {
565 return 0;
566 }
567 }
568
569 /* they have the same type */
570 /* left first */
571 if (STREQ(rpa->view, STEREO_LEFT_NAME)) {
572 return 0;
573 }
574 if (STREQ(rpb->view, STEREO_LEFT_NAME)) {
575 return 1;
576 }
577
578 /* right second */
579 if (STREQ(rpa->view, STEREO_RIGHT_NAME)) {
580 return 0;
581 }
582 if (STREQ(rpb->view, STEREO_RIGHT_NAME)) {
583 return 1;
584 }
585
586 /* remaining in ascending id order */
587 return (rpa->view_id < rpb->view_id);
588}
589
591 ExrReadHandle *exrhandle, const char *colorspace, bool predivide, int rectx, int recty)
592{
593 RenderResult *rr = MEM_new<RenderResult>(__func__);
594
595 rr->rectx = rectx;
596 rr->recty = recty;
597 IMB_exr_get_ppm(exrhandle, rr->ppm);
598
599 Vector<ExrPassInfo> entries = IMB_exr_get_passes(exrhandle);
600
601 /* Create views. */
602 VectorSet<std::string> view_names;
603 for (const StringRefNull &view : IMB_exr_get_views(exrhandle)) {
604 view_names.add(std::string(view));
605 }
606 if (view_names.is_empty()) {
607 view_names.add("");
608 }
609 for (const std::string &name : view_names) {
610 render_result_add_view(rr, name.c_str());
611 }
612
613 /* Read all passes. */
614 IMB_exr_read_passes(exrhandle, entries, colorspace, predivide);
615
616 /* Create corresponding render layers and render passes. */
617 for (ExrPassInfo &entry : entries) {
618 if (entry.ibuf == nullptr) {
619 continue;
620 }
621
622 /* Find or create render layer. */
623 RenderLayer *rl = static_cast<RenderLayer *>(
624 BLI_findstring(&rr->layers, entry.layer.c_str(), offsetof(RenderLayer, name)));
625
626 if (rl == nullptr) {
627 rl = MEM_new<RenderLayer>(__func__);
628 BLI_addtail(&rr->layers, rl);
629 BLI_strncpy(rl->name, entry.layer.c_str(), EXR_LAY_MAXNAME);
630 rl->rectx = rectx;
631 rl->recty = recty;
632 }
633
634 /* Create render pass. */
635 RenderPass *rpass = MEM_new<RenderPass>(__func__);
636 BLI_addtail(&rl->passes, rpass);
637 rpass->rectx = rectx;
638 rpass->recty = recty;
639 rpass->channels = entry.ibuf->channels;
640 STRNCPY(rpass->chan_id, entry.chan_id.c_str());
641 STRNCPY(rpass->name, entry.pass.c_str());
642 STRNCPY(rpass->view, entry.view.c_str());
643 rl->passflag |= passtype_from_name(rpass->name);
645 rpass->fullname, nullptr, rpass->name, rpass->view, rpass->chan_id, -1);
646 rpass->view_id = (rpass->view[0] != '\0') ?
647 BLI_findstringindex(&rr->views, rpass->view, offsetof(RenderView, name)) :
648 0;
649
650 /* Transfer image buffer. */
651 rpass->ibuf = entry.ibuf;
652 }
653
654 /* Render result passes are sorted within a layer. */
655 for (RenderLayer &rl : rr->layers) {
657 }
658
659 return rr;
660}
661
662void render_result_view_new(RenderResult *rr, const char *viewname)
663{
664 RenderView *rv = MEM_new<RenderView>("new render view");
665 BLI_addtail(&rr->views, rv);
666 STRNCPY_UTF8(rv->name, viewname);
667}
668
670{
671 /* clear previously existing views - for sequencer */
673
674 /* check renderdata for amount of views */
675 if (rd->scemode & R_MULTIVIEW) {
676 for (SceneRenderView &srv : rd->views) {
677 if (BKE_scene_multiview_is_render_view_active(rd, &srv) == false) {
678 continue;
679 }
681 }
682 }
683
684 /* we always need at least one view */
685 if (rr->views.is_empty()) {
687 }
688}
689
691
692/* -------------------------------------------------------------------- */
695
696static void do_merge_tile(
697 RenderResult *rr, RenderResult *rrpart, float *target, float *tile, int pixsize)
698{
699 int y, tilex, tiley;
700 size_t ofs, copylen;
701
702 copylen = tilex = rrpart->rectx;
703 tiley = rrpart->recty;
704
705 ofs = (size_t(rrpart->tilerect.ymin) * rr->rectx + rrpart->tilerect.xmin);
706 target += pixsize * ofs;
707
708 copylen *= sizeof(float) * pixsize;
709 tilex *= pixsize;
710 ofs = pixsize * rr->rectx;
711
712 for (y = 0; y < tiley; y++) {
713 memcpy(target, tile, copylen);
714 target += ofs;
715 tile += tilex;
716 }
717}
718
720{
721 rcti tile_region;
722 BLI_rcti_init(&tile_region,
723 rrpart->tilerect.xmin,
724 rrpart->tilerect.xmin + rrpart->rectx,
725 rrpart->tilerect.ymin,
726 rrpart->tilerect.ymin + rrpart->recty);
727
728 for (RenderLayer &rl : rr->layers) {
729 RenderLayer *rlp = RE_GetRenderLayer(rrpart, rl.name);
730
731 if (rlp) {
732 /* Passes are allocated in sync. */
733 for (RenderPass *rpass = rl.passes.first(), *rpassp = rlp->passes.first(); rpass && rpassp;
734 rpass = rpass->next)
735 {
736 /* For save buffers, skip any passes that are only saved to disk. */
737 if (rpass->ibuf == nullptr || rpassp->ibuf == nullptr) {
738 continue;
739 }
740 if (rpass->ibuf->float_data() == nullptr || rpassp->ibuf->float_data() == nullptr) {
741 continue;
742 }
743 /* Render-result have all passes, render-part only the active view's passes. */
744 if (!STREQ(rpassp->fullname, rpass->fullname)) {
745 continue;
746 }
747
748 do_merge_tile(rr,
749 rrpart,
750 rpass->ibuf->float_data_for_write(),
751 rpassp->ibuf->float_data_for_write(),
752 rpass->channels);
753
754 IMB_partial_update_mark_region(rpass->ibuf, tile_region);
755
756 /* manually get next render pass */
757 rpassp = rpassp->next;
758 }
759 }
760 }
761}
762
764
765/* -------------------------------------------------------------------- */
768
770{
771 /* all layers except the active one get temporally pushed away */
772
773 /* officially pushed result should be nullptr... error can happen with do_seq */
775
776 re->pushedresult = re->result;
777 re->result = nullptr;
778}
779
781{
782 if (re->result == nullptr) {
783 printf("pop render result error; no current result!\n");
784 return;
785 }
786
787 if (!re->pushedresult) {
788 return;
789 }
790
791 if (re->pushedresult->rectx == re->result->rectx && re->pushedresult->recty == re->result->recty)
792 {
793 /* find which layer in re->pushedresult should be replaced */
794 RenderLayer *rl = re->result->layers.first();
795
796 /* render result should be empty after this */
797 BLI_remlink(&re->result->layers, rl);
798
799 /* reconstruct render result layers */
800 for (ViewLayer &view_layer : re->scene->view_layers) {
801 if (STREQ(view_layer.name, re->single_view_layer)) {
802 BLI_addtail(&re->result->layers, rl);
803 }
804 else {
805 RenderLayer *rlpush = RE_GetRenderLayer(re->pushedresult, view_layer.name);
806 if (rlpush) {
807 BLI_remlink(&re->pushedresult->layers, rlpush);
808 BLI_addtail(&re->result->layers, rlpush);
809 }
810 }
811 }
812 }
813
815 re->pushedresult = nullptr;
816}
817
819 RenderLayer *rl_single,
820 ReportList *reports,
821 const char *filepath)
822{
823 ExrReadHandle *exrhandle = IMB_exr_open(filepath);
824 if (exrhandle == nullptr) {
825 return false;
826 }
827
828 const int2 size = IMB_exr_get_size(exrhandle);
829 const int rectx = size.x;
830 const int recty = size.y;
831
832 ListBaseT<RenderLayer> layers = (rr) ? rr->layers : ListBaseT<RenderLayer>{rl_single, rl_single};
833 const int expected_rectx = (rr) ? rr->rectx : rl_single->rectx;
834 const int expected_recty = (rr) ? rr->recty : rl_single->recty;
835
836 if (rectx != expected_rectx || recty != expected_recty) {
837 BKE_reportf(reports,
838 RPT_ERROR,
839 "Reading render result: dimensions don't match, expected %dx%d",
840 expected_rectx,
841 expected_recty);
842 IMB_exr_close(exrhandle);
843 return true;
844 }
845
846 /* Build vector of passes to read. */
847 const Vector<ExrPassInfo> file_passes = IMB_exr_get_passes(exrhandle);
848 Vector<ExrPassInfo> requests;
849
850 for (RenderLayer &rl : layers) {
851 if (rl_single && rl_single != &rl) {
852 continue;
853 }
854 for (RenderPass &rpass : rl.passes) {
855 const ExrPassInfo *layer_match = nullptr;
856 const ExrPassInfo *single_layer_match = nullptr;
857 for (const ExrPassInfo &info : file_passes) {
858 if (info.pass != rpass.name || info.view != rpass.view) {
859 continue;
860 }
861
862 if (info.layer == rl.name) {
863 layer_match = &info;
864 }
865 else if (rl_single && info.layer.is_empty()) {
866 single_layer_match = &info;
867 }
868 }
869
871 rpass.fullname, nullptr, rpass.name, rpass.view, rpass.chan_id, -1);
872
873 /* Prefer with layer name included, otherwise read without layer name. */
874 const ExrPassInfo *match = layer_match ? layer_match : single_layer_match;
875 if (match == nullptr) {
876 BKE_reportf(nullptr,
878 "Reading render result: expected pass \"%s.%s\" not found",
879 rl.name,
880 rpass.name);
881 continue;
882 }
883
884 if (rpass.ibuf == nullptr) {
885 BKE_reportf(nullptr,
887 "Reading render result: pass \"%s.%s\" has no buffer, skipping",
888 rl.name,
889 rpass.name);
890 continue;
891 }
892
893 if (match->channels != rpass.channels) {
894 /* Only a non-fatal warning, IMB_exr_read_passes will accept this
895 * and leave missing channels 0. */
896 BKE_reportf(nullptr,
898 "Reading render result: pass \"%s.%s\" has %d channels, expected %d",
899 rl.name,
900 rpass.name,
901 match->channels,
902 rpass.channels);
903 }
904
905 requests.append({.layer = match->layer,
906 .pass = match->pass,
907 .view = match->view,
908 .chan_id = match->chan_id,
909 .ibuf = rpass.ibuf});
910 }
911 }
912
913 IMB_exr_read_passes(exrhandle, requests);
914 for (const auto &request : requests) {
915 IMB_partial_update_mark_full(request.ibuf);
916 }
917 IMB_exr_close(exrhandle);
918
919 return true;
920}
921
922#define FILE_CACHE_MAX (FILE_MAXDIR + FILE_MAXFILE + MAX_ID_NAME + 100)
923
925 const char *root,
926 char r_path[FILE_CACHE_MAX])
927{
928 char filename_full[FILE_MAXFILE + MAX_ID_NAME + 100];
930 char dirname[FILE_MAXDIR];
931 char path_digest[16] = {0};
932 char path_hexdigest[33];
933
934 /* If root is relative, use either current .blend file dir, or temp one if not saved. */
935 const char *blendfile_path = BKE_main_blendfile_path_from_global();
936 if (blendfile_path[0] != '\0') {
937 BLI_path_split_dir_file(blendfile_path, dirname, sizeof(dirname), filename, sizeof(filename));
938 BLI_path_extension_strip(filename); /* Strip `.blend`. */
939 BLI_hash_md5_buffer(blendfile_path, strlen(blendfile_path), path_digest);
940 }
941 else {
943 STRNCPY(filename, "UNSAVED");
944 }
945 BLI_hash_md5_to_hexdigest(path_digest, path_hexdigest);
946
947 /* Default to *non-volatile* temp dir. */
948 char root_buf[FILE_MAX];
949 if (*root == '\0') {
950 root = BKE_tempdir_base();
951 }
952 else if (BLI_path_is_rel(root)) {
953 STRNCPY(root_buf, root);
954 BLI_path_abs(root_buf, dirname);
955 root = root_buf;
956 }
957
958 /* FIXME: MAX_ID_NAME & FILE_MAXFILE
959 *
960 * If #filename is already long (it is initialized from the blend-file name itself), adding the
961 * scene name can cause the file name to be truncated.
962 */
963 SNPRINTF(filename_full, "cached_RR_%s_%s_%s.exr", filename, sce->id.name + 2, path_hexdigest);
964
965 BLI_path_join(r_path, FILE_CACHE_MAX, root, filename_full);
966}
967
969{
970 RenderResult *rr = re->result;
971 char str[FILE_CACHE_MAX];
972 const char *root = U.render_cachedir;
973
975
977 printf("Caching exr file, %dx%d, %s\n", rr->rectx, rr->recty, str);
978
979 BKE_image_render_write_exr(nullptr, rr, str, nullptr, true, nullptr, -1);
980}
981
983{
984 /* File path to cache. */
985 char filepath[FILE_CACHE_MAX] = "";
986 const char *root = U.render_cachedir;
987 render_result_exr_file_cache_path(re->scene, root, filepath);
988
989 printf("read exr cache file: %s\n", filepath);
990
991 /* Try opening the file. */
992 ExrReadHandle *exrhandle = IMB_exr_open(filepath);
993 if (exrhandle == nullptr) {
994 printf("cannot read: %s\n", filepath);
995 return false;
996 }
997
998 const int2 size = IMB_exr_get_size(exrhandle);
999
1000 /* Read file contents into render result. */
1003
1004 re->result = render_result_new_from_exr(exrhandle, colorspace, false, size.x, size.y);
1005
1006 IMB_exr_close(exrhandle);
1007
1008 return true;
1009}
1010
1012
1013/* -------------------------------------------------------------------- */
1016
1018 const ImageFormatData *imf,
1019 const float dither,
1020 const int view_id)
1021{
1022 ImBuf *ibuf = IMB_allocImBuf(rr->rectx, rr->recty, ImBufFlags::Zero);
1023 ibuf->color_mode = imf->color_mode;
1024 RenderView *rv = RE_RenderViewGetById(rr, view_id);
1025
1026 /* if not exists, BKE_imbuf_write makes one */
1027 if (rv->ibuf) {
1028 ibuf->byte_buffer = rv->ibuf->byte_buffer;
1029 ibuf->float_buffer = rv->ibuf->float_buffer;
1030 ibuf->channels = rv->ibuf->channels;
1031 }
1032
1035
1036 /* float factor for random dither, imbuf takes care of it */
1037 ibuf->dither = dither;
1038
1039 copy_v2_v2_db(ibuf->ppm, rr->ppm);
1040
1041 /* prepare to gamma correct to sRGB color space
1042 * note that sequence editor can generate 8bpc render buffers
1043 */
1044 if (ibuf->byte_data()) {
1047 {
1048 if (imf->depth == R_IMF_CHAN_DEPTH_8) {
1049 ibuf->float_buffer = {};
1050 }
1051 else {
1052 IMB_float_from_byte(ibuf);
1053 }
1054 }
1055 else {
1056 ibuf->float_buffer = {};
1057 }
1058 }
1059
1060 /* Color -> gray-scale. */
1061 /* editing directly would alter the render view */
1063 !(ibuf->float_data() && !ibuf->byte_data() && ibuf->channels == 1))
1064 {
1065 ImBuf *ibuf_bw = IMB_dupImBuf(ibuf);
1066 IMB_color_to_bw(ibuf_bw);
1067 IMB_freeImBuf(ibuf);
1068 ibuf = ibuf_bw;
1069 }
1070
1071 return ibuf;
1072}
1073
1074void RE_render_result_rect_from_ibuf(RenderResult *rr, const ImBuf *ibuf, const int view_id)
1075{
1076 RenderView *rv = RE_RenderViewGetById(rr, view_id);
1077
1078 ImBuf *rv_ibuf = RE_RenderViewEnsureImBuf(rr, rv);
1079
1080 if (ibuf->float_data()) {
1081 rr->have_combined = true;
1082
1083 rv_ibuf->float_buffer = ibuf->float_buffer;
1084
1085 /* TSK! Since sequence render doesn't free the *rr render result, the old rect32
1086 * can hang around when sequence render has rendered a 32 bits one before */
1087 IMB_free_byte_pixels(rv_ibuf);
1088 }
1089 else if (ibuf->byte_data()) {
1090 rr->have_combined = true;
1091
1092 rv_ibuf->byte_buffer = ibuf->byte_buffer;
1093
1094 /* Same things as above, old rectf can hang around from previous render. */
1095 IMB_free_float_pixels(rv_ibuf);
1096 }
1097
1099}
1100
1101void render_result_rect_fill_zero(RenderResult *rr, const int view_id)
1102{
1103 RenderView *rv = RE_RenderViewGetById(rr, view_id);
1104
1105 ImBuf *ibuf = RE_RenderViewEnsureImBuf(rr, rv);
1106
1107 if (!ibuf->float_data() && !ibuf->byte_data()) {
1108 ibuf->assign_byte_data(
1109 MEM_new_array_zeroed<uint8_t>(4 * size_t(rr->rectx) * size_t(rr->recty), __func__));
1111 return;
1112 }
1113
1114 if (ibuf->float_data()) {
1115 memset(ibuf->float_data_for_write(), 0, sizeof(float[4]) * rr->rectx * rr->recty);
1116 }
1117
1118 if (ibuf->byte_data()) {
1119 memset(ibuf->byte_data_for_write(), 0, 4 * rr->rectx * rr->recty);
1120 }
1121
1123}
1124
1126 uint8_t *rect,
1127 int rectx,
1128 int recty,
1129 const ColorManagedViewSettings *view_settings,
1130 const ColorManagedDisplaySettings *display_settings,
1131 const int view_id)
1132{
1133 const RenderView *rv = RE_RenderViewGetById(rr, view_id);
1134 if (const ImBuf *ibuf = rv ? rv->ibuf : nullptr) {
1135 if (ibuf->byte_data()) {
1136 memcpy(rect, ibuf->byte_data(), sizeof(int) * rr->rectx * rr->recty);
1137 return;
1138 }
1139 if (ibuf->float_data()) {
1141 rect, ibuf->float_data(), rr->rectx, rr->recty, view_settings, display_settings);
1142 return;
1143 }
1144 }
1145
1146 /* Fill with black as a fallback. */
1147 memset(rect, 0, sizeof(int) * rectx * recty);
1148}
1149
1151
1152/* -------------------------------------------------------------------- */
1155
1157{
1158 if (result == nullptr) {
1159 return false;
1160 }
1161
1162 const RenderView *rv = result->views.first();
1163 if (rv == nullptr) {
1164 return false;
1165 }
1166
1167 return (rv->ibuf);
1168}
1169
1171{
1172 for (const RenderView &rview : result->views) {
1173 ImBuf *ibuf = rview.ibuf;
1174 if (!ibuf) {
1175 continue;
1176 }
1177 if (ibuf->byte_data() && !ibuf->float_data()) {
1178 return false;
1179 }
1180 }
1181
1182 return true;
1183}
1184
1186{
1187 if (!BLI_findstring(&result->views, STEREO_LEFT_NAME, offsetof(RenderView, name))) {
1188 return false;
1189 }
1190
1192 return false;
1193 }
1194
1195 return true;
1196}
1197
1199{
1200 RenderView *rv = static_cast<RenderView *>(BLI_findlink(&rr->views, view_id));
1201 BLI_assert(rr->views.first());
1202 return rv ? rv : rr->views.first();
1203}
1204
1206{
1207 RenderView *rv = static_cast<RenderView *>(
1208 BLI_findstring(&rr->views, viewname, offsetof(RenderView, name)));
1209 BLI_assert(rr->views.first());
1210 return rv ? rv : rr->views.first();
1211}
1212
1214{
1215 RenderPass *new_rpass = MEM_new<RenderPass>("new render pass", *rpass);
1216 new_rpass->next = new_rpass->prev = nullptr;
1217
1218 new_rpass->ibuf = IMB_dupImBuf(rpass->ibuf);
1219
1220 return new_rpass;
1221}
1222
1224{
1225 RenderLayer *new_rl = MEM_new<RenderLayer>("new render layer", *rl);
1226 new_rl->next = new_rl->prev = nullptr;
1227 new_rl->passes.first_ = new_rl->passes.last_ = nullptr;
1228 for (RenderPass &rpass : rl->passes) {
1229 RenderPass *new_rpass = duplicate_render_pass(&rpass);
1230 BLI_addtail(&new_rl->passes, new_rpass);
1231 }
1232 return new_rl;
1233}
1234
1236{
1237 RenderView *new_rview = MEM_new<RenderView>("new render view", *rview);
1238
1239 new_rview->ibuf = IMB_dupImBuf(rview->ibuf);
1240
1241 return new_rview;
1242}
1243
1245{
1246 RenderResult *new_rr = MEM_new<RenderResult>("new duplicated render result", *rr);
1247 new_rr->next = new_rr->prev = nullptr;
1248 new_rr->layers.first_ = new_rr->layers.last_ = nullptr;
1249 new_rr->views.first_ = new_rr->views.last_ = nullptr;
1250 for (RenderLayer &rl : rr->layers) {
1251 RenderLayer *new_rl = duplicate_render_layer(&rl);
1252 BLI_addtail(&new_rr->layers, new_rl);
1253 }
1254 for (RenderView &rview : rr->views) {
1255 RenderView *new_rview = duplicate_render_view(&rview);
1256 BLI_addtail(&new_rr->views, new_rview);
1257 }
1258
1259 new_rr->ibuf = IMB_dupImBuf(rr->ibuf);
1260
1261 new_rr->stamp_data = BKE_stamp_data_copy(new_rr->stamp_data);
1262
1263 copy_v2_v2_db(new_rr->ppm, rr->ppm);
1264
1265 return new_rr;
1266}
1267
1269{
1270 if (!render_pass->ibuf) {
1271 render_pass->ibuf = IMB_allocImBuf(render_pass->rectx, render_pass->recty, ImBufFlags::Zero);
1272 render_pass->ibuf->color_mode = IMB_color_mode_from_channels(render_pass->channels);
1273 render_pass->ibuf->channels = render_pass->channels;
1275 }
1276
1277 return render_pass->ibuf;
1278}
1279
1280ImBuf *RE_RenderViewEnsureImBuf(const RenderResult *render_result, RenderView *render_view)
1281{
1282 if (!render_view->ibuf) {
1283 render_view->ibuf = IMB_allocImBuf(
1284 render_result->rectx, render_result->recty, ImBufFlags::Zero);
1285 }
1286
1287 return render_view->ibuf;
1288}
1289
1290bool RE_RenderPassIsColor(const RenderPass *render_pass)
1291{
1292 return IMB_chan_id_is_color(render_pass->chan_id);
1293}
1294
1296
1297} // namespace blender
#define FILE_MAXFILE
#define FILE_MAX
#define BLI_path_join(...)
#define FILE_MAXDIR
#define SNPRINTF(dst, format,...)
#define STRNCPY_UTF8(dst, src)
const char * dirname(char *path)
#define MAX_ID_NAME
Definition DNA_ID.h:367
#define RE_PASSNAME_COMBINED
#define RE_PASSNAME_VECTOR
#define RE_PASSNAME_DEPTH
#define STEREO_LEFT_NAME
#define STEREO_RIGHT_NAME
#define EXR_LAY_MAXNAME
#define EXR_PASS_MAXNAME
Read Blender memory allocation and freeing.
#define ARRAY_SET_ITEMS(...)
#define STREQ(a, b)
bool add(const Key &key)
void append(const T &value)
#define offsetof(t, d)
#define str(s)
const ccl_global KernelWorkTile * tile
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
std::string filename(const std::string_view &str, size_t pos)
BMesh Iterators.
bool BKE_scene_multiview_is_render_view_active(const RenderData *rd, const SceneRenderView *srv)
Definition scene.cc:3241
static int passtype_from_name(const char *name)
bool bool BLI_path_extension_strip(char *path) ATTR_NONNULL(1)
void IMB_colormanagement_assign_float_colorspace(ImBuf *ibuf, const char *name)
UserDef U
Definition blender.cc:58
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
bool render_result_exr_file_read_path(RenderResult *rr, RenderLayer *rl_single, ReportList *reports, const char *filepath)
void render_result_single_layer_begin(Render *re)
char * STRNCPY(char(&dst)[N], const char *src)
void IMB_free_byte_pixels(ImBuf *ibuf)
RenderView * RE_RenderViewGetById(RenderResult *rr, const int view_id)
void * BLI_hash_md5_buffer(const char *buffer, size_t len, void *resblock)
Definition hash_md5.cc:345
@ RPT_WARNING
Definition BKE_report.hh:40
void render_result_views_new(RenderResult *rr, const RenderData *rd)
int bool bool bool size_t BLI_str_partition(const char *str, const char delim[], const char **sep, const char **suf) ATTR_NONNULL(1
unsigned int uint
Definition BKE_text.h:55
bool RE_HasCombinedLayer(const RenderResult *result)
bool BLI_path_abs(char path[FILE_MAX], const char *basepath) ATTR_NONNULL(1
void BLI_addhead(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:98
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)
int2 IMB_exr_get_size(ExrReadHandle *handle)
ExrReadHandle * IMB_exr_open(const char *filepath)
void RE_render_result_rect_from_ibuf(RenderResult *rr, const ImBuf *ibuf, const int view_id)
bool render_result_exr_file_cache_read(Render *re)
bool IMB_chan_id_is_color(StringRef chan_id)
void render_result_views_shallowdelete(RenderResult *rr)
RenderLayer * RE_GetRenderLayer(RenderResult *rr, const char *name)
StampData * BKE_stamp_data_copy(const StampData *stamp_data)
void * BLI_findstring(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:615
static int order_render_passes(const void *a, const void *b)
void render_result_rect_get_pixels(RenderResult *rr, uint8_t *rect, int rectx, int recty, const ColorManagedViewSettings *view_settings, const ColorManagedDisplaySettings *display_settings, const int view_id)
const char * BKE_main_blendfile_path_from_global()
Definition main.cc:1063
void render_result_rect_fill_zero(RenderResult *rr, const int view_id)
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 IMB_colormanagement_scene_linear_to_display_buffer(uint8_t *display_buffer, const float *linear_buffer, int width, int height, const ColorManagedViewSettings *view_settings, const ColorManagedDisplaySettings *display_settings)
static RenderLayer * duplicate_render_layer(RenderLayer *rl)
ImBuf * IMB_dupImBuf(const ImBuf *ibuf1)
RenderPass * render_layer_add_pass(RenderResult *rr, RenderLayer *rl, int channels, const char *name, const char *viewname, const char *chan_id, const bool allocate)
void RE_FreeRenderResult(RenderResult *rr)
void BKE_scene_ppm_get(const RenderData *rd, double r_ppm[2])
Definition scene.cc:3487
void render_result_free_list(ListBaseT< RenderResult > *lb, RenderResult *rr)
void IMB_float_from_byte(ImBuf *ibuf)
void BKE_stamp_data_free(StampData *stamp_data)
@ R_IMF_IMTYPE_MULTILAYER
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
int BLI_findstringindex(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:794
BLI_INLINE int BLI_rcti_size_y(const struct rcti *rct)
Definition BLI_rect.hh:207
char * BLI_strncpy(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
void IMB_freeImBuf(ImBuf *ibuf)
VecBase< int32_t, 2 > int2
void render_result_passes_allocated_ensure(RenderResult *rr)
static RenderPass * duplicate_render_pass(RenderPass *rpass)
RenderResult * render_result_new_from_exr(ExrReadHandle *exrhandle, const char *colorspace, bool predivide, int rectx, int recty)
ImColorMode IMB_color_mode_from_channels(int channels)
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
const char * IMB_colormanagement_role_colorspace_name_get(int role)
BMesh const char void * data
void BLI_insertlinkafter(ListBase *listbase, void *vprevlink, void *vnewlink) ATTR_NONNULL(1)
Definition listbase.cc:339
static void do_merge_tile(RenderResult *rr, RenderResult *rrpart, float *target, float *tile, int pixsize)
Vector< StringRefNull > IMB_exr_get_views(ExrReadHandle *handle)
static void assign_render_pass_ibuf_colorspace(RenderPass &render_pass)
unsigned char uint8_t
Definition BKE_text.h:79
MINLINE void copy_v2_v2_db(double r[2], const double a[2])
void render_result_free_gpu_texture_caches(RenderResult *rr)
bool RE_RenderPassIsColor(const RenderPass *render_pass)
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:277
void render_result_free(RenderResult *rr)
bool IMB_exr_get_ppm(ExrReadHandle *handle, double ppm[2])
void IMB_partial_update_mark_region(ImBuf *ibuf, const rcti &region)
void RE_pass_set_buffer_data(RenderPass *pass, float *data)
void IMB_partial_update_mark_full(ImBuf *ibuf)
void IMB_color_to_bw(ImBuf *ibuf)
const char * BKE_tempdir_base() ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL
Definition appdir.cc:1288
size_t BLI_string_join_array_by_sep_char(char *result, size_t result_maxncpy, char sep, const char *strings[], uint strings_num) ATTR_NONNULL()
BLI_INLINE int BLI_rcti_size_x(const struct rcti *rct)
Definition BLI_rect.hh:203
void render_result_exr_file_cache_write(Render *re)
void IMB_exr_close(ExrReadHandle *handle)
eImageFormatDepth BKE_imtype_valid_depths(char imtype)
void void BLI_listbase_sort(ListBase *listbase, int(*cmp)(const void *, const void *)) ATTR_NONNULL(1
Definition listbase.cc:319
ImBuf * IMB_allocImBuf(unsigned int x, unsigned int y, ImBufFlags flags)
ImBuf * RE_RenderPassEnsureImBuf(RenderPass *render_pass)
bool RE_HasFloatPixels(const RenderResult *result)
void BLI_rcti_init(struct rcti *rect, int xmin, int xmax, int ymin, int ymax)
Definition rct.cc:428
void render_result_clone_passes(Render *re, RenderResult *rr, const char *viewname)
static void render_result_views_free(RenderResult *rr)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
Definition report.cc:191
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
char * BLI_hash_md5_to_hexdigest(const void *resblock, char r_hex_digest[33])
Definition hash_md5.cc:381
bool BLI_path_is_rel(const char *path) ATTR_NONNULL(1) ATTR_WARN_UNUSED_RESULT
void IMB_free_gpu_textures(ImBuf *ibuf)
Definition util_gpu.cc:835
static void render_result_add_view(RenderResult *rr, const char *name)
void BLI_path_split_dir_file(const char *filepath, char *dir, size_t dir_maxncpy, char *file, size_t file_maxncpy) ATTR_NONNULL(1
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)
RenderView * RE_RenderViewGetByName(RenderResult *rr, const char *viewname)
ImBuf * RE_RenderViewEnsureImBuf(const RenderResult *render_result, RenderView *render_view)
bool BKE_image_render_write_exr(ReportList *reports, const RenderResult *rr, const char *filepath, const ImageFormatData *imf, bool save_as_render, const char *view, int layer)
void render_result_single_layer_end(Render *re)
RenderResult * RE_DuplicateRenderResult(RenderResult *rr)
Vector< ExrPassInfo > IMB_exr_get_passes(ExrReadHandle *handle)
void render_result_merge(RenderResult *rr, RenderResult *rrpart)
RenderResult * render_result_new(Render *re, const rcti *partrct, const char *layername, const char *viewname)
void IMB_free_float_pixels(ImBuf *ibuf)
void render_result_view_new(RenderResult *rr, const char *viewname)
void IMB_exr_read_passes(ExrReadHandle *handle, MutableSpan< ExrPassInfo > entries, const char *src_colorspace=nullptr, bool predivide=false)
void render_result_views_shallowcopy(RenderResult *dst, RenderResult *src)
static void render_layer_allocate_pass(RenderResult *rr, RenderPass *rp)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
static RenderView * duplicate_render_view(RenderView *rview)
static void render_result_exr_file_cache_path(Scene *sce, const char *root, char r_path[FILE_CACHE_MAX])
#define FILE_CACHE_MAX
#define CHECK_PASS(NAME)
#define FOREACH_VIEW_LAYER_TO_RENDER_END
#define PASS_VECTOR_MAX
#define FOREACH_VIEW_LAYER_TO_RENDER_BEGIN(re_, iter_)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
RenderResult * result
StringRefNull chan_id
StringRefNull layer
char name[258]
Definition DNA_ID.h:433
ImBufFloatBuffer float_buffer
ImBufByteBuffer byte_buffer
const uint8_t * byte_data() const
uint8_t * byte_data_for_write()
Definition allocimbuf.cc:60
const float * float_data() const
ImColorMode color_mode
void assign_byte_data(uint8_t *data)
float * float_data_for_write()
Definition allocimbuf.cc:79
void assign_float_data(float *data)
ListBaseT< SceneRenderView > views
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
struct ImBuf * ibuf
Definition RE_pipeline.h:54
RenderResult * pushedresult
char single_view_layer[MAX_NAME]
ListBaseT< ViewLayer > view_layers