Blender V5.3
node_shader_preview.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
24
25#include "BLI_listbase.hh"
26#include "BLI_math_base_c.hh"
27#include "BLI_string_utf8.hh"
28
29#include "DNA_camera_types.h"
30#include "DNA_material_types.h"
31#include "DNA_world_types.h"
32
33#include "RNA_access.hh"
34#include "RNA_prototypes.hh"
35
36#include "BKE_colortools.hh"
39#include "BKE_context.hh"
40#include "BKE_global.hh"
41#include "BKE_layer.hh"
42#include "BKE_lib_id.hh"
43#include "BKE_main.hh"
44#include "BKE_material.hh"
45#include "BKE_node.hh"
47#include "BKE_node_runtime.hh"
49
50#include "DEG_depsgraph.hh"
51
52#include "IMB_imbuf.hh"
53
54#include "WM_api.hh"
55
56#include "ED_node_preview.hh"
57#include "ED_render.hh"
58#include "ED_screen.hh"
59
60#include "node_intern.hh"
61
63/* -------------------------------------------------------------------- */
66using NodeSocketPair = std::pair<bNode *, bNodeSocket *>;
67
70 Scene *scene = nullptr;
71 /* Pointer to the job's stop variable which is used to know when the job is asked for finishing.
72 * The idea is that the renderer will read this value frequently and abort the render if it is
73 * true. */
74 bool *stop = nullptr;
75 /* Pointer to the job's update variable which is set to true to refresh the UI when the renderer
76 * is delivering a fresh result. It allows the job to give some UI refresh tags to the WM. */
77 bool *do_update = nullptr;
78
79 Material *mat_copy = nullptr;
80 World *world_simple = nullptr;
84 /* TreePath used to locate the nodetree.
85 * bNodeTreePath elements have some listbase pointers which should not be used. */
89
91 bool rendering_AOVs = false;
92
93 Main *bmain = nullptr;
94};
95
97
98/* -------------------------------------------------------------------- */
101
102static void ensure_nodetree_previews(const bContext &C,
103 NestedTreePreviews &tree_previews,
104 Material &material,
105 ListBaseT<bNodeTreePath> &treepath);
106
107static std::optional<ComputeContextHash> get_compute_context_hash_for_node_editor(
108 const SpaceNode &snode)
109{
111 for (const bNodeTreePath &item : snode.treepath) {
112 treepath.append(&item);
113 }
114
115 if (treepath.is_empty()) {
116 return std::nullopt;
117 }
118 if (treepath.size() == 1) {
119 /* Top group. */
121 hash.v1 = hash.v2 = 0;
122 return hash;
123 }
124 bke::ComputeContextCache compute_context_cache;
125 const ComputeContext *compute_context = nullptr;
126 for (const int i : treepath.index_range().drop_back(1)) {
127 /* The tree path contains the name of the node but not its ID. */
128 bNodeTree *tree = treepath[i]->nodetree;
129 const bNode *node = bke::node_find_node_by_name(*tree, treepath[i + 1]->node_name);
130 if (node == nullptr) {
131 /* The current tree path is invalid, probably because some parent group node has been
132 * deleted. */
133 return std::nullopt;
134 }
135 compute_context = &compute_context_cache.for_group_node(
136 compute_context, node->identifier, tree);
137 }
138 return compute_context->hash();
139}
140
142{
143 if (snode.id == nullptr || GS(snode.id->name) != ID_MA) {
144 return nullptr;
145 }
146 NestedTreePreviews *tree_previews = nullptr;
148 tree_previews = snode.runtime->tree_previews_per_context
149 .lookup_or_add_cb(*hash,
150 [&]() {
151 return std::make_unique<NestedTreePreviews>(
152 U.node_preview_res);
153 })
154 .get();
155 Material *ma = reinterpret_cast<Material *>(snode.id);
156 ensure_nodetree_previews(C, *tree_previews, *ma, snode.treepath);
157 }
158 return tree_previews;
159}
160
162
163/* -------------------------------------------------------------------- */
166
168{
169 Material *ma_copy = reinterpret_cast<Material *>(
170 BKE_id_copy_ex(nullptr,
171 &mat.id,
172 nullptr,
174 return ma_copy;
175}
176
178{
179 const Main *bmain = job_data.bmain;
180 const Scene *scene_orig = job_data.scene;
181 Scene *scene_preview;
182
183 memcpy(pr_main->filepath, BKE_main_blendfile_path(bmain), sizeof(pr_main->filepath));
184
185 if (pr_main == nullptr) {
186 return nullptr;
187 }
188 scene_preview = pr_main->scenes.first();
189 if (scene_preview == nullptr) {
190 return nullptr;
191 }
192
193 ViewLayer *view_layer = scene_preview->view_layers.first();
194
195 /* Only enable the combined render-pass. */
196 view_layer->passflag = SCE_PASS_COMBINED;
198
199 /* This flag tells render to not execute depsgraph or F-Curves etc. */
200 scene_preview->r.scemode |= R_BUTS_PREVIEW;
201 scene_preview->r.mode |= R_PERSISTENT_DATA;
202 STRNCPY_UTF8(scene_preview->r.engine, scene_orig->r.engine);
203
204 scene_preview->r.color_mgt_flag = scene_orig->r.color_mgt_flag;
206 &scene_orig->display_settings);
207
210
211 scene_preview->r.alphamode = R_ADDSKY;
212
213 scene_preview->r.cfra = scene_orig->r.cfra;
214
215 /* Setup the world. */
216 if (job_data.world_simple == nullptr) {
218 }
219 scene_preview->world = job_data.world_simple;
220 ED_preview_world_simple_set_rgb(scene_preview->world, float4{0.05f, 0.05f, 0.05f, 0.05f});
221
222 BLI_addtail(&pr_main->materials, job_data.mat_copy);
223
225 pr_main, scene_preview, view_layer, job_data.preview_type, PR_BUTS_RENDER);
226
227 BKE_view_layer_synced_ensure(*pr_main, scene_preview, view_layer);
228 for (Base &base : *BKE_view_layer_object_bases_get(view_layer)) {
229 if (base.object->id.name[2] == 'p') {
230 if (OB_TYPE_SUPPORT_MATERIAL(base.object->type)) {
231 /* Don't use BKE_object_material_assign, it changed mat->id.us, which shows in the UI. */
232 Material ***matar = BKE_object_material_array_p(base.object);
233 int actcol = max_ii(base.object->actcol - 1, 0);
234
235 if (matar && actcol < base.object->totcol) {
236 (*matar)[actcol] = job_data.mat_copy;
237 }
238 }
239 else if (base.object->type == OB_LAMP) {
241 }
242 }
243 }
244
245 return scene_preview;
246}
247
249
250/* -------------------------------------------------------------------- */
253
260{
261 bNodeSocket *socket = get_main_socket(ntree, node, SOCK_OUT);
262 if (socket == nullptr) {
263 socket = get_main_socket(ntree, node, SOCK_IN);
264 if (socket != nullptr && socket->link == nullptr) {
265 if (!ELEM(socket->type, SOCK_FLOAT, SOCK_VECTOR, SOCK_RGBA)) {
266 /* We can not preview a socket with no link and no manual value. */
267 return nullptr;
268 }
269 }
270 }
271 return socket;
272}
273
274static bool socket_use_aov(const bNodeSocket *socket)
275{
276 return socket == nullptr || socket->type != SOCK_SHADER;
277}
278
279static bool node_use_aov(bNodeTree &ntree, const bNode *node)
280{
281 bNode *node_preview = const_cast<bNode *>(node);
282 bNodeSocket *socket_preview = node_find_preview_socket(ntree, *node_preview);
283 return socket_use_aov(socket_preview);
284}
285
287 const char *layer_name,
288 const char *pass_name)
289{
290 RenderLayer *rl;
291 if (layer_name) {
292 rl = RE_GetRenderLayer(&rr, layer_name);
293 }
294 else {
295 rl = rr.layers.first();
296 }
297 if (rl == nullptr) {
298 return nullptr;
299 }
300 RenderPass *rp;
301 if (pass_name) {
302 rp = RE_pass_find_by_name(rl, pass_name, nullptr);
303 }
304 else {
305 rp = rl->passes.first();
306 }
307 ImBuf *ibuf = rp ? rp->ibuf : nullptr;
308 return ibuf;
309}
310
312 NestedTreePreviews &tree_previews,
313 const bNode &node)
314{
315 if (tree_previews.previews_render == nullptr) {
316 return nullptr;
317 }
318
320 ImBuf *&image_cached = tree_previews.previews_map.lookup_or_add(node.identifier, nullptr);
321 if (rr == nullptr) {
322 return image_cached;
323 }
324 if (image_cached == nullptr) {
325 if (tree_previews.rendering == false) {
327 }
328 else {
329 /* When the render process is started, the user must see that the preview area is open. */
330 ImBuf *image_latest = nullptr;
331 if (node_use_aov(ntree, &node)) {
332 image_latest = get_image_from_viewlayer_and_pass(*rr, nullptr, node.name);
333 }
334 else {
335 image_latest = get_image_from_viewlayer_and_pass(*rr, node.name, nullptr);
336 }
337 if (image_latest) {
338 IMB_refImBuf(image_latest);
339 image_cached = image_latest;
340 }
341 }
342 }
343 return image_cached;
344}
345
347{
348 if (tree_previews.previews_render == nullptr) {
349 return;
350 }
351 RE_ReleaseResult(tree_previews.previews_render);
352}
353
361 bNode &nested_node,
362 bNodeSocket &nested_socket,
363 bNode &final_node,
364 bNodeSocket &final_socket,
365 const char *route_name)
366{
367 bNode *nested_node_iter = &nested_node;
368 bNodeSocket *nested_socket_iter = &nested_socket;
369 for (int i = treepath.size() - 1; i > 0; --i) {
370 bNodeTreePath *path = treepath[i];
371 bNodeTreePath *path_prev = treepath[i - 1];
372 bNodeTree *nested_nt = path->nodetree;
373 bNode *output_node = nullptr;
374 for (bNode *iter_node : nested_nt->all_nodes()) {
375 if (iter_node->is_group_output() && iter_node->flag & NODE_DO_OUTPUT) {
376 output_node = iter_node;
377 break;
378 }
379 }
380 if (output_node == nullptr) {
381 output_node = bke::node_add_static_node(nullptr, *nested_nt, NODE_GROUP_OUTPUT);
382 output_node->flag |= NODE_DO_OUTPUT;
383 }
384
385 nested_nt->tree_interface.add_socket(
386 route_name, "", nested_socket_iter->idname, NODE_INTERFACE_SOCKET_OUTPUT, nullptr);
387 BKE_ntree_update_after_single_tree_change(*G.pr_main, *nested_nt);
388 bNodeSocket *out_socket = bke::node_find_enabled_input_socket(*output_node, route_name);
389
391 *nested_nt, *nested_node_iter, *nested_socket_iter, *output_node, *out_socket);
392 BKE_ntree_update_after_single_tree_change(*G.pr_main, *nested_nt);
393
394 /* Change the `nested_node` pointer to the nested node-group instance node. The tree path
395 * contains the name of the instance node but not its ID. */
396 nested_node_iter = bke::node_find_node_by_name(*path_prev->nodetree, path->node_name);
397
398 /* Update the sockets of the node because we added a new interface. */
399 BKE_ntree_update_tag_node_property(path_prev->nodetree, nested_node_iter);
401
402 /* Now use the newly created socket of the node-group as previewing socket of the node-group
403 * instance node. */
404 nested_socket_iter = bke::node_find_enabled_output_socket(*nested_node_iter, route_name);
405 }
406
407 bke::node_add_link(*treepath.first()->nodetree,
408 *nested_node_iter,
409 *nested_socket_iter,
410 final_node,
411 final_socket);
412}
413
414/* Connect the node to the output of the first nodetree from `treepath`. Last element of `treepath`
415 * should be the path to the node's nodetree */
417 NodeSocketPair nodesocket,
418 bNode &output_node)
419{
420 bNodeSocket *out_surface_socket = nullptr;
421 bNodeTree *main_nt = treepath.first()->nodetree;
422 bNode *node_preview = nodesocket.first;
423 bNodeSocket *socket_preview = nodesocket.second;
424 if (socket_preview == nullptr) {
425 return;
426 }
427 if (socket_preview->in_out == SOCK_IN) {
428 BLI_assert(socket_preview->link != nullptr);
429 node_preview = socket_preview->link->fromnode;
430 socket_preview = socket_preview->link->fromsock;
431 }
432 /* Ensure output is usable. */
433 out_surface_socket = bke::node_find_socket(output_node, SOCK_IN, "Surface"_ustr);
434 if (out_surface_socket->link) {
435 /* Make sure no node is already wired to the output before wiring. */
436 bke::node_remove_link(main_nt, *out_surface_socket->link);
437 }
438
440 *node_preview,
441 *socket_preview,
442 output_node,
443 *out_surface_socket,
444 nodesocket.first->name);
446}
447
448/* Connect the nodes to some aov nodes located in the first nodetree from `treepath`. Last element
449 * of `treepath` should be the path to the nodes nodetree. */
451 const Span<NodeSocketPair> nodesocket_span)
452{
453 if (nodesocket_span.is_empty()) {
454 return;
455 }
456 bNodeTree *main_nt = treepath.first()->nodetree;
457 bNodeTree *active_nt = treepath.last()->nodetree;
458 for (const NodeSocketPair &nodesocket : nodesocket_span) {
459 bNode *node_preview = nodesocket.first;
460 bNodeSocket *socket_preview = nodesocket.second;
461
462 bNode *aov_node = bke::node_add_static_node(nullptr, *main_nt, SH_NODE_OUTPUT_AOV);
463 STRNCPY_UTF8(reinterpret_cast<NodeShaderOutputAOV *>(aov_node->storage)->name,
464 nodesocket.first->name);
465 if (socket_preview == nullptr) {
466 continue;
467 }
468 bNodeSocket *aov_socket = bke::node_find_socket(*aov_node, SOCK_IN, "Color"_ustr);
469 if (socket_preview->in_out == SOCK_IN) {
470 if (socket_preview->link == nullptr) {
471 /* Copy the custom value of the socket directly to the AOV node.
472 * If the socket does not support custom values, it will just render black. */
473 float vec[4] = {0., 0., 0., 1.};
474 PointerRNA ptr;
475 switch (socket_preview->type) {
476 case SOCK_FLOAT:
478 id_cast<ID *>(active_nt), RNA_NodeSocket, socket_preview);
479 vec[0] = RNA_float_get(&ptr, "default_value");
480 vec[1] = vec[0];
481 vec[2] = vec[0];
482 break;
483 case SOCK_VECTOR:
484 case SOCK_RGBA:
486 id_cast<ID *>(active_nt), RNA_NodeSocket, socket_preview);
487 RNA_float_get_array(&ptr, "default_value", vec);
488 break;
489 default:
490 break;
491 }
492 ptr = RNA_pointer_create_discrete(id_cast<ID *>(active_nt), RNA_NodeSocket, aov_socket);
493 RNA_float_set_array(&ptr, "default_value", vec);
494 continue;
495 }
496 node_preview = socket_preview->link->fromnode;
497 socket_preview = socket_preview->link->fromsock;
498 }
500 treepath, *node_preview, *socket_preview, *aov_node, *aov_socket, nodesocket.first->name);
501 }
503}
504
505/* Called by renderer, checks job stops. */
506static bool nodetree_previews_break(void *spv)
507{
508 ShaderNodesPreviewJob *job_data = static_cast<ShaderNodesPreviewJob *>(spv);
509
510 return *(job_data->stop);
511}
512
513static bool prepare_viewlayer_update(void *pvl_data, ViewLayer *vl, Depsgraph *depsgraph)
514{
515 NodeSocketPair nodesocket = {nullptr, nullptr};
516 ShaderNodesPreviewJob *job_data = static_cast<ShaderNodesPreviewJob *>(pvl_data);
517 for (const NodeSocketPair &nodesocket_iter : job_data->shader_nodes) {
518 if (STREQ(vl->name, nodesocket_iter.first->name)) {
519 nodesocket = nodesocket_iter;
520 job_data->rendering_node = nodesocket_iter.first;
521 job_data->rendering_AOVs = false;
522 break;
523 }
524 }
525 if (nodesocket.first == nullptr) {
526 job_data->rendering_node = nullptr;
527 job_data->rendering_AOVs = true;
528 /* The AOV layer is the default `ViewLayer` of the scene(which should be the first one). */
529 return job_data->AOV_nodes.size() > 0 && !vl->prev;
530 }
531
532 bNodeSocket *displacement_socket = bke::node_find_socket(
533 *job_data->mat_output_copy, SOCK_IN, "Displacement"_ustr);
534 if (job_data->mat_displacement_copy.first != nullptr && displacement_socket->link == nullptr) {
535 bke::node_add_link(*job_data->treepath_copy.first()->nodetree,
536 *job_data->mat_displacement_copy.first,
537 *job_data->mat_displacement_copy.second,
538 *job_data->mat_output_copy,
539 *displacement_socket);
540 }
541 connect_node_to_surface_output(job_data->treepath_copy, nodesocket, *job_data->mat_output_copy);
542
543 if (depsgraph != nullptr) {
544 /* Used to refresh the dependency graph so that the material can be updated. */
545 for (bNodeTreePath *path_iter : job_data->treepath_copy) {
547 G.pr_main, depsgraph, &path_iter->nodetree->id, ID_RECALC_NTREE_OUTPUT);
548 }
549 }
550 return true;
551}
552
553/* Called by renderer, refresh the UI. */
554static void all_nodes_preview_update(void *npv, RenderResult *rr)
555{
556 ShaderNodesPreviewJob *job_data = static_cast<ShaderNodesPreviewJob *>(npv);
557 *job_data->do_update = true;
558 if (bNode *node = job_data->rendering_node) {
559 ImBuf *&image_cached = job_data->tree_previews->previews_map.lookup_or_add(node->identifier,
560 nullptr);
561 ImBuf *image_latest = get_image_from_viewlayer_and_pass(*rr, node->name, nullptr);
562 if (image_latest == nullptr) {
563 return;
564 }
565 if (image_cached != image_latest) {
566 if (image_cached != nullptr) {
567 IMB_freeImBuf(image_cached);
568 }
569 IMB_refImBuf(image_latest);
570 image_cached = image_latest;
571 }
572 }
573 if (job_data->rendering_AOVs) {
574 for (const NodeSocketPair &nodesocket_iter : job_data->AOV_nodes) {
575 ImBuf *&image_cached = job_data->tree_previews->previews_map.lookup_or_add(
576 nodesocket_iter.first->identifier, nullptr);
578 *rr, nullptr, nodesocket_iter.first->name);
579 if (image_latest == nullptr) {
580 continue;
581 }
582 if (image_cached != image_latest) {
583 if (image_cached != nullptr) {
584 IMB_freeImBuf(image_cached);
585 }
586 IMB_refImBuf(image_latest);
587 image_cached = image_latest;
588 }
589 }
590 }
591}
592
594{
595 /* Get the stuff from the builtin preview dbase. */
596 Scene *scene = preview_prepare_scene(job_data, G.pr_main);
597 if (scene == nullptr) {
598 return;
599 }
600 Span<bNodeTreePath *> treepath = job_data.treepath_copy;
601
602 /* AOV nodes are rendered in the first RenderLayer so we route them now. */
603 connect_nodes_to_aovs(treepath, job_data.AOV_nodes);
604
605 /* Create the AOV passes for the viewlayer. */
606 ViewLayer *AOV_layer = scene->view_layers.first();
607 for (const NodeSocketPair &nodesocket_iter : job_data.shader_nodes) {
609 job_data.bmain, scene, nodesocket_iter.first->name, AOV_layer, VIEWLAYER_ADD_COPY);
610 STRNCPY_UTF8(vl->name, nodesocket_iter.first->name);
611 }
612 for (const NodeSocketPair &nodesocket_iter : job_data.AOV_nodes) {
613 ViewLayerAOV *aov = BKE_view_layer_add_aov(AOV_layer);
614 STRNCPY_UTF8(aov->name, nodesocket_iter.first->name);
615 }
616 scene->r.xsch = job_data.tree_previews->preview_size;
617 scene->r.ysch = job_data.tree_previews->preview_size;
618 scene->r.size = 100;
619
620 if (job_data.tree_previews->previews_render == nullptr) {
622 }
623 Render *re = job_data.tree_previews->previews_render;
624
625 /* `sce->r` gets copied in RE_InitState. */
627 scene->r.scemode &= ~R_NO_IMAGE_LOAD;
628
630
634
635 /* Lens adjust. */
636 float oldlens = reinterpret_cast<Camera *>(scene->camera->data)->lens;
637
638 RE_ClearResult(re);
639 RE_PreviewRender(re, G.pr_main, scene);
640
641 reinterpret_cast<Camera *>(scene->camera->data)->lens = oldlens;
642
643 /* Free the aov layers and the layers generated for each node. */
644 AOV_layer->aovs.free_no_destruct();
645 ViewLayer *vl = AOV_layer->next;
646 while (vl) {
647 ViewLayer *vl_rem = vl;
648 vl = vl->next;
649 BLI_remlink(&scene->view_layers, vl_rem);
650 BKE_view_layer_free(vl_rem);
651 }
652}
653
655
656/* -------------------------------------------------------------------- */
659
660static void update_needed_flag(NestedTreePreviews &tree_previews,
661 const bNodeTree &nt,
662 ePreviewType preview_type)
663{
664 if (tree_previews.rendering) {
666 tree_previews.restart_needed = true;
667 return;
668 }
669 if (preview_type != tree_previews.rendering_preview_type) {
670 tree_previews.restart_needed = true;
671 return;
672 }
673 }
674 else {
676 tree_previews.restart_needed = true;
677 return;
678 }
679 if (preview_type != tree_previews.cached_preview_type) {
680 tree_previews.restart_needed = true;
681 return;
682 }
683 }
684 if (tree_previews.preview_size != U.node_preview_res) {
685 tree_previews.restart_needed = true;
686 return;
687 }
688}
689
690static void shader_preview_startjob(void *customdata, wmJobWorkerStatus *worker_status)
691{
692 ShaderNodesPreviewJob *job_data = static_cast<ShaderNodesPreviewJob *>(customdata);
693
694 job_data->stop = &worker_status->stop;
695 job_data->do_update = &worker_status->do_update;
696 worker_status->do_update = true;
697 bool size_changed = job_data->tree_previews->preview_size != U.node_preview_res;
698 if (size_changed) {
699 job_data->tree_previews->preview_size = U.node_preview_res;
700 }
701
702 for (bNode *node_iter : job_data->mat_copy->nodetree->all_nodes()) {
703 if (node_iter->flag & NODE_DO_OUTPUT) {
704 node_iter->flag &= ~NODE_DO_OUTPUT;
705 bNodeSocket *disp_socket = bke::node_find_socket(*node_iter, SOCK_IN, "Displacement"_ustr);
706 if (disp_socket != nullptr && disp_socket->link != nullptr) {
707 job_data->mat_displacement_copy = std::make_pair(disp_socket->link->fromnode,
708 disp_socket->link->fromsock);
709 }
710 break;
711 }
712 }
713
714 /* Add a new output node used only for the previews. This is useful to keep the previously
715 * connected links (for previewing the output nodes for example). */
717 nullptr, *job_data->mat_copy->nodetree, SH_NODE_OUTPUT_MATERIAL);
718 job_data->mat_output_copy->flag |= NODE_DO_OUTPUT;
719
720 bNodeTree *active_nodetree = job_data->treepath_copy.last()->nodetree;
721 active_nodetree->ensure_topology_cache();
722 for (bNode *node : active_nodetree->all_nodes()) {
723 if (!(node->flag & NODE_PREVIEW)) {
724 /* Clear the cached preview for this node to be sure that the preview is re-rendered if
725 * needed. */
726 if (ImBuf **ibuf = job_data->tree_previews->previews_map.lookup_ptr(node->identifier)) {
727 IMB_freeImBuf(*ibuf);
728 *ibuf = nullptr;
729 }
730 continue;
731 }
732 bNodeSocket *preview_socket = node_find_preview_socket(*active_nodetree, *node);
733 if (socket_use_aov(preview_socket)) {
734 job_data->AOV_nodes.append({node, preview_socket});
735 }
736 else {
737 job_data->shader_nodes.append({node, preview_socket});
738 }
739 }
740
741 if (job_data->tree_previews->preview_size > 0) {
742 preview_render(*job_data);
743 }
744}
745
746static void shader_preview_free(void *customdata)
747{
748 ShaderNodesPreviewJob *job_data = static_cast<ShaderNodesPreviewJob *>(customdata);
749 for (bNodeTreePath *path : job_data->treepath_copy) {
750 MEM_delete(path);
751 }
752 job_data->treepath_copy.clear();
753 job_data->tree_previews->rendering = false;
756 job_data->tree_previews->cached_preview_type = job_data->preview_type;
757 if (job_data->mat_copy != nullptr) {
758 BLI_remlink(&G.pr_main->materials, job_data->mat_copy);
759 BKE_id_free(G.pr_main, &job_data->mat_copy->id);
760 job_data->mat_copy = nullptr;
761 }
762 if (job_data->world_simple != nullptr) {
763 BKE_id_free(G.pr_main, &job_data->world_simple->id);
764 }
765 MEM_delete(job_data);
766}
767
769 NestedTreePreviews &tree_previews,
770 Material &material,
771 ListBaseT<bNodeTreePath> &treepath)
772{
773 Scene *scene = CTX_data_scene(&C);
775 return;
776 }
777
778 bNodeTree *displayed_nodetree = treepath.last()->nodetree;
779 ePreviewType preview_type = MA_FLAT;
780 if (CTX_wm_space_node(&C)->overlay.preview_shape == SN_OVERLAY_PREVIEW_3D) {
781 preview_type = ePreviewType(material.pr_type);
782 }
783 update_needed_flag(tree_previews, *displayed_nodetree, preview_type);
784 if (!(tree_previews.restart_needed)) {
785 return;
786 }
787 if (tree_previews.rendering) {
789 return;
790 }
791 tree_previews.rendering = true;
792 tree_previews.restart_needed = false;
794 displayed_nodetree->runtime->previews_refresh_state;
795 tree_previews.rendering_preview_type = preview_type;
796
798
799 wmJob *wm_job = WM_jobs_get(CTX_wm_manager(&C),
802 "Generating shader previews...",
805 ShaderNodesPreviewJob *job_data = MEM_new<ShaderNodesPreviewJob>(__func__);
806
807 job_data->scene = scene;
808 job_data->tree_previews = &tree_previews;
809 job_data->bmain = CTX_data_main(&C);
810 job_data->mat_copy = duplicate_material(material);
811 job_data->rendering_node = nullptr;
812 job_data->rendering_AOVs = false;
813 job_data->preview_type = preview_type;
814
815 /* Update the treepath copied to fit the structure of the nodetree copied. */
816 bNodeTreePath *root_path = MEM_new<bNodeTreePath>(__func__);
817 root_path->nodetree = job_data->mat_copy->nodetree;
818 job_data->treepath_copy.append(root_path);
819 for (bNodeTreePath *original_path = treepath.first()->next; original_path;
820 original_path = original_path->next)
821 {
822 bNode *parent = bke::node_find_node_by_name(*job_data->treepath_copy.last()->nodetree,
823 original_path->node_name);
824 if (parent == nullptr) {
825 /* In some cases (e.g. muted nodes), there may not be an equivalent node in the copied
826 * nodetree. In that case, just skip the node. */
827 continue;
828 }
829 bNodeTreePath *new_path = MEM_new<bNodeTreePath>(__func__);
830 memcpy(new_path, original_path, sizeof(bNodeTreePath));
831 new_path->nodetree = reinterpret_cast<bNodeTree *>(parent->id);
832 job_data->treepath_copy.append(new_path);
833 }
834
836 WM_jobs_timer(wm_job, 0.2, NC_NODE, NC_NODE);
837 WM_jobs_callbacks(wm_job, shader_preview_startjob, nullptr, nullptr, nullptr);
838
839 WM_jobs_start(CTX_wm_manager(&C), wm_job);
840}
841
843{
844 /* This should not be called from the drawing pass, because it will result in a deadlock. */
846 snode.runtime->tree_previews_per_context.clear();
847}
848
850
851} // namespace blender::ed::space_node
General operations, lookup, etc. for materials.
#define NODE_GROUP_OUTPUT
Definition BKE_node.hh:869
#define SH_NODE_OUTPUT_MATERIAL
#define SH_NODE_OUTPUT_AOV
#define STRNCPY_UTF8(dst, src)
#define OB_TYPE_SUPPORT_MATERIAL(_type)
#define C
Definition RandGen.cpp:29
#define NC_NODE
Definition WM_types.hh:407
#define ELEM(...)
#define STREQ(a, b)
const ComputeContextHash & hash() const
constexpr IndexRange drop_back(int64_t n) const
constexpr const T & first() const
Definition BLI_span.hh:319
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr const T & last(const int64_t n=0) const
Definition BLI_span.hh:329
constexpr bool is_empty() const
Definition BLI_span.hh:264
int64_t size() const
void append(const T &value)
bool is_empty() const
IndexRange index_range() const
const GroupNodeComputeContext & for_group_node(const ComputeContext *parent, int32_t node_id, const bNodeTree *tree=nullptr)
bNode * node_find_node_by_name(bNodeTree &ntree, StringRefNull name)
Definition node.cc:4047
bNodeSocket * node_find_enabled_input_socket(bNode &node, StringRef name)
Definition node.cc:3068
void node_remove_link(bNodeTree *ntree, bNodeLink &link)
Definition node.cc:4676
bNodeSocket * node_find_enabled_output_socket(bNode &node, StringRef name)
Definition node.cc:3073
bNode * node_add_static_node(const bContext *C, bNodeTree &ntree, int type)
Definition node.cc:4283
bNodeLink & node_add_link(bNodeTree &ntree, bNode &fromnode, bNodeSocket &fromsock, bNode &tonode, bNodeSocket &tosock)
Definition node.cc:4638
bNodeSocket * node_find_socket(bNode &node, eNodeSocketInOut in_out, UString identifier)
Definition node.cc:3036
static bool node_use_aov(bNodeTree &ntree, const bNode *node)
static void shader_preview_free(void *customdata)
static void shader_preview_startjob(void *customdata, wmJobWorkerStatus *worker_status)
static void connect_nodes_to_aovs(const Span< bNodeTreePath * > treepath, const Span< NodeSocketPair > nodesocket_span)
static void connect_nested_node_to_node(const Span< bNodeTreePath * > treepath, bNode &nested_node, bNodeSocket &nested_socket, bNode &final_node, bNodeSocket &final_socket, const char *route_name)
static bool socket_use_aov(const bNodeSocket *socket)
static Material * duplicate_material(const Material &mat)
void free_previews(wmWindowManager &wm, SpaceNode &snode)
ImBuf * node_preview_acquire_ibuf(bNodeTree &ntree, NestedTreePreviews &tree_previews, const bNode &node)
static std::optional< ComputeContextHash > get_compute_context_hash_for_node_editor(const SpaceNode &snode)
std::pair< bNode *, bNodeSocket * > NodeSocketPair
static void ensure_nodetree_previews(const bContext &C, NestedTreePreviews &tree_previews, Material &material, ListBaseT< bNodeTreePath > &treepath)
static bool nodetree_previews_break(void *spv)
static bNodeSocket * node_find_preview_socket(bNodeTree &ntree, bNode &node)
static Scene * preview_prepare_scene(ShaderNodesPreviewJob &job_data, Main *pr_main)
static void connect_node_to_surface_output(const Span< bNodeTreePath * > treepath, NodeSocketPair nodesocket, bNode &output_node)
NestedTreePreviews * get_nested_previews(const bContext &C, SpaceNode &snode)
static void all_nodes_preview_update(void *npv, RenderResult *rr)
void node_release_preview_ibuf(NestedTreePreviews &tree_previews)
static void preview_render(ShaderNodesPreviewJob &job_data)
static void update_needed_flag(NestedTreePreviews &tree_previews, const bNodeTree &nt, ePreviewType preview_type)
static bool prepare_viewlayer_update(void *pvl_data, ViewLayer *vl, Depsgraph *depsgraph)
bNodeSocket * get_main_socket(bNodeTree &ntree, bNode &node, eNodeSocketInOut in_out)
static ImBuf * get_image_from_viewlayer_and_pass(RenderResult &rr, const char *layer_name, const char *pass_name)
UserDef U
Definition blender.cc:58
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void RNA_float_set_array(PointerRNA *ptr, const char *name, const float *values)
void WM_jobs_callbacks(wmJob *wm_job, wm_jobs_start_callback startjob, void(*initjob)(void *), void(*update)(void *), void(*endjob)(void *))
Definition wm_jobs.cc:407
void WM_jobs_stop_type(wmWindowManager *wm, const void *owner, eWM_JobType job_type)
Definition wm_jobs.cc:666
void RE_test_break_cb(Render *re, void *handle, bool(*f)(void *handle))
Material *** BKE_object_material_array_p(Object *ob)
@ BASE_ENABLED_AND_MAYBE_VISIBLE_IN_VIEWPORT
@ VIEWLAYER_ADD_COPY
Definition BKE_layer.hh:42
@ WM_JOB_TYPE_RENDER_PREVIEW
Definition WM_api.hh:2012
RenderLayer * RE_GetRenderLayer(RenderResult *rr, const char *name)
void DEG_graph_id_tag_update(Main *bmain, Depsgraph *depsgraph, ID *id, unsigned int flags)
void IMB_refImBuf(ImBuf *ibuf)
World * ED_preview_prepare_world_simple(Main *bmain)
wmWindow * CTX_wm_window(const bContext *C)
MINLINE int max_ii(int a, int b)
void WM_jobs_customdata_set(wmJob *wm_job, void *customdata, void(*free)(void *customdata))
Definition wm_jobs.cc:377
void RE_prepare_viewlayer_cb(Render *re, void *handle, bool(*f)(void *handle, ViewLayer *vl, Depsgraph *depsgraph))
@ WM_JOB_EXCL_RENDER
Definition WM_api.hh:1995
@ WM_JOB_BACKGROUND
Definition WM_api.hh:1999
Render * RE_NewRender(const void *owner)
void BKE_color_managed_view_settings_copy(ColorManagedViewSettings *new_settings, const ColorManagedViewSettings *settings)
@ LIB_ID_COPY_LOCALIZE
@ LIB_ID_COPY_NO_ANIMDATA
@ LIB_ID_CREATE_LOCAL
void WM_jobs_start(wmWindowManager *wm, wmJob *wm_job)
Definition wm_jobs.cc:498
Global G
Definition blender.cc:57
const char * BKE_main_blendfile_path(const Main *bmain) ATTR_NONNULL()
Definition main.cc:1058
VecBase< float, 4 > float4
ViewLayerAOV * BKE_view_layer_add_aov(ViewLayer *view_layer)
void ED_preview_world_simple_set_rgb(World *world, const float color[4])
void IMB_freeImBuf(ImBuf *ibuf)
void BKE_color_managed_display_settings_copy(ColorManagedDisplaySettings *new_settings, const ColorManagedDisplaySettings *settings)
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
wmWindowManager * CTX_wm_manager(const bContext *C)
void BKE_ntree_update_after_single_tree_change(Main &bmain, bNodeTree &modified_tree, const NodeTreeUpdateExtraParams &params={})
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
SpaceNode * CTX_wm_space_node(const bContext *C)
bool ED_check_engine_supports_preview(const Scene *scene)
void ED_preview_set_visibility(Main *pr_main, Scene *scene, ViewLayer *view_layer, ePreviewType pr_type, ePreviewRenderMethod pr_method)
void BKE_id_free(Main *bmain, void *idv)
RenderResult * RE_AcquireResultRead(Render *re)
RenderPass * RE_pass_find_by_name(RenderLayer *rl, const char *name, const char *viewname)
void WM_jobs_kill_type(wmWindowManager *wm, const void *owner, int job_type)
Definition wm_jobs.cc:642
void BKE_view_layer_free(ViewLayer *view_layer)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
void BKE_ntree_update_tag_node_property(bNodeTree *ntree, bNode *node)
Main * CTX_data_main(const bContext *C)
void RE_display_update_cb(Render *re, void *handle, void(*f)(void *handle, RenderResult *rr))
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
@ ID_RECALC_NTREE_OUTPUT
Definition DNA_ID.h:1155
ID_Type GS(const char *name)
Definition DNA_ID.h:410
ViewLayer * BKE_view_layer_add(const Main *bmain, Scene *scene, const char *name, ViewLayer *view_layer_source, int type)
void BKE_color_managed_view_settings_free(ColorManagedViewSettings *settings)
Scene * CTX_data_scene(const bContext *C)
void RE_PreviewRender(Render *re, Main *bmain, Scene *sce)
@ SCE_DISPLAY_AA_SAMPLES_8
ID * BKE_id_copy_ex(Main *bmain, const ID *id, ID **new_id_p, int flag)
Definition lib_id.cc:851
@ SN_OVERLAY_PREVIEW_3D
void WM_jobs_timer(wmJob *wm_job, double time_step, uint note, uint endnote, void(*timer_step)(void *))
Definition wm_jobs.cc:393
ListBaseT< Base > * BKE_view_layer_object_bases_get(ViewLayer *view_layer)
float RNA_float_get(PointerRNA *ptr, const char *name)
void ED_preview_ensure_dbase(bool with_gpencil)
@ PR_BUTS_RENDER
Definition ED_render.hh:74
void RNA_float_get_array(PointerRNA *ptr, const char *name, float *values)
#define hash
Definition noise_c.cc:156
char name[258]
Definition DNA_ID.h:433
char filepath[1024]
Definition BKE_main.hh:267
ListBaseT< Material > materials
Definition BKE_main.hh:392
ListBaseT< Scene > scenes
Definition BKE_main.hh:386
ListBaseT< RenderPass > passes
Definition RE_pipeline.h:99
struct ImBuf * ibuf
Definition RE_pipeline.h:72
ListBaseT< RenderLayer > layers
eSceneDisplay_AA render_aa
ListBaseT< ViewLayer > view_layers
struct World * world
struct SceneDisplay display
ColorManagedViewSettings view_settings
struct Object * camera
ColorManagedDisplaySettings display_settings
struct RenderData r
ListBaseT< bNodeTreePath > treepath
ed::space_node::SpaceNode_Runtime * runtime
eViewLayerEEVEEPassType render_passes
struct ViewLayerEEVEE eevee
ListBaseT< ViewLayerAOV > aovs
struct ViewLayer * prev
struct ViewLayer * next
eNodeSocketDatatype type
struct bNodeLink * link
eNodeSocketInOut in_out
struct bNodeTreePath * next
struct bNodeTree * nodetree
bNodeTreeInterface tree_interface
bke::bNodeTreeRuntime * runtime
Map< ComputeContextHash, std::unique_ptr< space_node::NestedTreePreviews > > tree_previews_per_context