53 while (rr->
views.first()) {
80 while (rr->
layers.first()) {
83 while (rl->
passes.first()) {
102 MEM_delete(rr->
error);
114 for (; rr; rr = rrnext) {
117 if (lb && lb->first_) {
142 if (dst ==
nullptr || src ==
nullptr) {
149 rv = MEM_new<RenderView>(
"new render view");
164 while (rr->
views.first()) {
208 for (
int x = rectsize - 1;
x >= 0;
x--) {
213 for (
int x = rectsize - 1;
x >= 0;
x--) {
214 buffer_data[
x] = 1e10f;
223 const char *viewname,
228 RenderPass *rpass = MEM_new<RenderPass>(name);
256 const char *layername,
257 const char *viewname)
266 if (rectx <= 0 || recty <= 0) {
270 rr = MEM_new<RenderResult>(
"new render result");
288 if (layername && layername[0]) {
289 if (!
STREQ(view_layer->name, layername)) {
294 rl = MEM_new<RenderLayer>(
"new render layer");
298 rl->
layflag = view_layer->layflag;
300 rl->
passflag = view_layer->passflag;
306 const char *view = rv.
name;
308 if (viewname && viewname[0]) {
309 if (!
STREQ(view, viewname)) {
321 if (rr->
layers.is_empty() && !(layername && layername[0])) {
322 rl = MEM_new<RenderLayer>(
"new render layer");
329 const char *view = rv.
name;
331 if (viewname && viewname[0]) {
332 if (!
STREQ(view, viewname)) {
377 if (viewname && viewname[0] && !
STREQ(main_rp.
view, viewname)) {
396 const char *layername,
397 const char *viewname,
401 if (layername && layername[0] && !
STREQ(rl.
name, layername)) {
406 const char *view = rv.
name;
408 if (viewname && viewname[0] && !
STREQ(view, viewname)) {
413 bool pass_exists =
false;
438 const char *passname,
439 const char *viewname,
444 const char *strings[4];
447 if (layname && layname[0]) {
448 strings[strings_len++] = layname;
450 if (passname && passname[0]) {
451 strings[strings_len++] = passname;
453 if (viewname && viewname[0]) {
454 strings[strings_len++] = viewname;
460 strings[strings_len++] = token;
468 const char delim[] = {
'.',
'\0'};
469 const char *sep, *suf;
472#define CHECK_PASS(NAME) \
473 if (STREQLEN(name, RE_PASSNAME_##NAME, len)) { \
474 return SCE_PASS_##NAME; \
509 RenderView *rv = MEM_new<RenderView>(
"new render view");
523 if (left_rv ==
nullptr) {
544 if (passtype_b && !passtype_a) {
547 if (passtype_a && !passtype_b) {
551 if (passtype_a && passtype_b) {
552 if (passtype_a > passtype_b) {
555 if (passtype_a < passtype_b) {
604 view_names.
add(std::string(view));
609 for (
const std::string &name : view_names) {
618 if (entry.ibuf ==
nullptr) {
627 rl = MEM_new<RenderLayer>(__func__);
635 RenderPass *rpass = MEM_new<RenderPass>(__func__);
637 rpass->
rectx = rectx;
638 rpass->
recty = recty;
639 rpass->
channels = entry.ibuf->channels;
651 rpass->
ibuf = entry.ibuf;
664 RenderView *rv = MEM_new<RenderView>(
"new render view");
685 if (rr->
views.is_empty()) {
702 copylen = tilex = rrpart->
rectx;
703 tiley = rrpart->
recty;
706 target += pixsize * ofs;
708 copylen *=
sizeof(
float) * pixsize;
710 ofs = pixsize * rr->
rectx;
712 for (
y = 0;
y < tiley;
y++) {
713 memcpy(target,
tile, copylen);
737 if (rpass->ibuf ==
nullptr || rpassp->ibuf ==
nullptr) {
740 if (rpass->ibuf->float_data() ==
nullptr || rpassp->ibuf->float_data() ==
nullptr) {
744 if (!
STREQ(rpassp->fullname, rpass->fullname)) {
751 rpassp->ibuf->float_data_for_write(),
757 rpassp = rpassp->next;
782 if (re->
result ==
nullptr) {
783 printf(
"pop render result error; no current result!\n");
821 const char *filepath)
824 if (exrhandle ==
nullptr) {
829 const int rectx = size.x;
830 const int recty = size.y;
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;
836 if (rectx != expected_rectx || recty != expected_recty) {
839 "Reading render result: dimensions don't match, expected %dx%d",
851 if (rl_single && rl_single != &rl) {
858 if (info.pass != rpass.
name || info.view != rpass.
view) {
862 if (info.layer == rl.name) {
865 else if (rl_single && info.layer.is_empty()) {
866 single_layer_match = &info;
874 const ExrPassInfo *match = layer_match ? layer_match : single_layer_match;
875 if (match ==
nullptr) {
878 "Reading render result: expected pass \"%s.%s\" not found",
884 if (rpass.
ibuf ==
nullptr) {
887 "Reading render result: pass \"%s.%s\" has no buffer, skipping",
898 "Reading render result: pass \"%s.%s\" has %d channels, expected %d",
909 .ibuf = rpass.
ibuf});
914 for (
const auto &request : requests) {
922#define FILE_CACHE_MAX (FILE_MAXDIR + FILE_MAXFILE + MAX_ID_NAME + 100)
931 char path_digest[16] = {0};
932 char path_hexdigest[33];
936 if (blendfile_path[0] !=
'\0') {
972 const char *root =
U.render_cachedir;
986 const char *root =
U.render_cachedir;
989 printf(
"read exr cache file: %s\n", filepath);
993 if (exrhandle ==
nullptr) {
994 printf(
"cannot read: %s\n", filepath);
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);
1139 if (ibuf->float_data()) {
1141 rect, ibuf->float_data(), rr->
rectx, rr->
recty, view_settings, display_settings);
1147 memset(rect, 0,
sizeof(
int) * rectx * recty);
1163 if (rv ==
nullptr) {
1202 return rv ? rv : rr->
views.first();
1210 return rv ? rv : rr->
views.first();
1215 RenderPass *new_rpass = MEM_new<RenderPass>(
"new render pass", *rpass);
1216 new_rpass->
next = new_rpass->
prev =
nullptr;
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;
1237 RenderView *new_rview = MEM_new<RenderView>(
"new render view", *rview);
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;
1270 if (!render_pass->
ibuf) {
1277 return render_pass->
ibuf;
1282 if (!render_view->
ibuf) {
1287 return render_view->
ibuf;
#define BLI_path_join(...)
#define SNPRINTF(dst, format,...)
#define STRNCPY_UTF8(dst, src)
const char * dirname(char *path)
#define RE_PASSNAME_COMBINED
#define RE_PASSNAME_VECTOR
#define RE_PASSNAME_DEPTH
#define STEREO_RIGHT_NAME
Read Blender memory allocation and freeing.
#define ARRAY_SET_ITEMS(...)
void append(const T &value)
const ccl_global KernelWorkTile * tile
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
std::string filename(const std::string_view &str, size_t pos)
bool BKE_scene_multiview_is_render_view_active(const RenderData *rd, const SceneRenderView *srv)
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)
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)
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
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)
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)
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()
@ COLOR_ROLE_SCENE_LINEAR
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])
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)
int BLI_findstringindex(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
BLI_INLINE int BLI_rcti_size_y(const struct rcti *rct)
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)
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)
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)
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)
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 ®ion)
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
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)
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
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)
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
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
char * BLI_hash_md5_to_hexdigest(const void *resblock, char r_hex_digest[33])
bool BLI_path_is_rel(const char *path) ATTR_NONNULL(1) ATTR_WARN_UNUSED_RESULT
void IMB_free_gpu_textures(ImBuf *ibuf)
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 FOREACH_VIEW_LAYER_TO_RENDER_END
#define FOREACH_VIEW_LAYER_TO_RENDER_BEGIN(re_, iter_)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
ImBufFloatBuffer float_buffer
ImBufByteBuffer byte_buffer
const uint8_t * byte_data() const
uint8_t * byte_data_for_write()
const float * float_data() const
void assign_byte_data(uint8_t *data)
float * float_data_for_write()
void assign_float_data(float *data)
ListBaseT< SceneRenderView > views
ListBaseT< RenderPass > passes
struct RenderLayer * next
struct RenderLayer * prev
struct RenderResult * prev
struct StampData * stamp_data
struct RenderResult * next
ListBaseT< RenderView > views
ListBaseT< RenderLayer > layers
RenderResult * pushedresult
char single_view_layer[MAX_NAME]
ListBaseT< ViewLayer > view_layers