56 const bNode &
node,
const bool build_meta_data)
100 const bNode &
node,
const bool build_meta_data)
107 switch (
node.custom1) {
187 layer_name.copy_utf8_truncated(
layer->name);
198 std::string first_layer_name;
202 if (first_layer_name.empty()) {
203 first_layer_name = layer_name;
206 if (layer_name == node_cryptomatte->
layer_name) {
213 const char *cstr = first_layer_name.c_str();
220 return session_ptr.release();
233 nc->
entries.free_no_destruct();
240 const bNode *src_node)
269 if (layers.is_empty()) {
281 if (output_pick.should_compute()) {
315 if (this->
context().use_gpu()) {
330 const Result &first_layer = layers[0];
347 const Result &first_layer = layers[0];
351 output.allocate_texture(domain);
375 float2 first_rank = float4(first_layer.load_pixel<Color>(texel)).xy();
376 float id_of_first_rank = first_rank.x;
381 std::memcpy(&hash_value, &id_of_first_rank, sizeof(uint32_t));
382 float green = float(hash_value << 8) / float(0xFFFFFFFFu);
383 float blue = float(hash_value << 16) / float(0xFFFFFFFFu);
385 output.store_pixel(texel, Color(id_of_first_rank, green, blue, 1.0f));
393 if (this->
context().use_gpu()) {
412 if (identifiers.is_empty()) {
420 for (
const Span<float> &identifier_slice : identifiers_slices) {
423 shader,
"identifiers", identifier_slice.size(), identifier_slice.data());
433 layer.unbind_as_texture();
448 constexpr int slice_size = 32;
449 const int slices_count = ((identifiers.
size() - 1) / slice_size) + 1;
450 for (
int i = 0; i < slices_count; i++) {
451 slices.append(identifiers.as_span().slice_safe(i * slice_size, slice_size));
467 if (identifiers.is_empty()) {
471 for (
const Result &layer_result : layers) {
482 float4 layer = float4(layer_result.load_pixel<Color>(texel));
485 float2 first_rank = layer.xy();
486 float2 second_rank = layer.zw();
490 float identifier_of_first_rank = first_rank.x;
491 float coverage_of_first_rank = first_rank.y;
492 float identifier_of_second_rank = second_rank.x;
493 float coverage_of_second_rank = second_rank.y;
497 float total_coverage = 0.0f;
498 for (const float &identifier : identifiers) {
499 if (identifier_of_first_rank == identifier) {
500 total_coverage += coverage_of_first_rank;
502 if (identifier_of_second_rank == identifier) {
503 total_coverage += coverage_of_second_rank;
518 if (this->
context().use_gpu()) {
555 output.allocate_texture(domain);
558 float4 input_color = float4(input.load_pixel<Color, true>(texel));
559 float input_matte = matte.load_pixel<float>(texel);
562 output.store_pixel(texel, Color(input_color * input_matte));
573 identifiers.append(cryptomatte_entry.encoded_hash);
589 .structure_type(StructureType::Dynamic);
624 row.
text =
RPT_(
"Node Unsupported");
626 "The Cryptomatte node in render mode is only supported for scene compositing");
627 row.
icon = ICON_STATUS_ERROR;
628 parameters.
rows.append(std::move(row));
643 row.
text =
RPT_(
"Passes Not Supported");
644 row.
tooltip =
TIP_(
"Render passes in the Viewport compositor are only supported in EEVEE");
645 row.
icon = ICON_STATUS_ERROR;
646 parameters.
rows.append(std::move(row));
654 using BaseCryptoMatteOperation::BaseCryptoMatteOperation;
689 for (
const auto [view_layer_index, view_layer] : scene->
view_layers.enumerate()) {
692 const char *cryptomatte_type =
nullptr;
693 const std::string layer_prefix = std::string(view_layer.name) +
".";
705 if (!cryptomatte_type) {
710 const int cryptomatte_layers_count = int(
math::ceil(view_layer.cryptomatte_levels / 2.0f));
711 for (
int i = 0; i < cryptomatte_layers_count; i++) {
712 const std::string pass_name = fmt::format(
"{}{:02}", cryptomatte_type, i);
713 Result pass_result = this->
context().get_pass(scene, view_layer_index, pass_name.c_str());
721 layers.append(std::move(pass_result));
748 if (!image_buffer || !
image->rr) {
764 const bool is_unnamed_layer = render_layer.
name[0] ==
'\0';
765 if (!is_unnamed_layer && !
StringRefNull(type_name).startswith(render_layer.
name)) {
777 if (combined_name == type_name || !
StringRef(combined_name).startswith(type_name)) {
781 pass_names.append(render_pass.
name);
785 if (!pass_names.is_empty()) {
793 image_user_for_layer.
layer = layer_index;
794 for (
const std::string &pass_name : pass_names) {
795 const Result &pass_result =
context().cache_manager().cached_images.get(
796 context(), *
image, image_user_for_layer, pass_name.c_str());
804 layers.append(std::move(layer_result));
814 if (render_layer->
name[0] ==
'\0') {
815 return std::string(render_pass->
name);
817 return std::string(render_layer->
name) +
"." + std::string(render_pass->
name);
828 return std::string(type_name);
837 return context().get_compositing_domain();
863 const int2 image_size =
int2(image_buffer->
x, image_buffer->
y);
865 return Domain(image_size);
879 return image_user_for_frame;
885 return reinterpret_cast<Scene *
>(
node().id);
891 return reinterpret_cast<Image *
>(
node().id);
912 "Generate matte for individual objects and materials using Cryptomatte render passes";
953 .default_value({0.0f, 0.0f, 0.0f, 1.0f})
954 .structure_type(StructureType::Dynamic);
956 b.add_output<
decl::Color>(
"Image"_ustr).structure_type(StructureType::Dynamic);
957 b.add_output<
decl::Float>(
"Matte"_ustr).structure_type(StructureType::Dynamic);
958 b.add_output<
decl::Color>(
"Pick"_ustr).structure_type(StructureType::Dynamic);
962 b.add_input<
decl::Color>(
"Crypto 00"_ustr).structure_type(StructureType::Dynamic);
967 for (
int i = 0; i < inputs_count; i++) {
968 const std::string name = fmt::format(
"Crypto {:02}", i);
987 using BaseCryptoMatteOperation::BaseCryptoMatteOperation;
998 for (
const bNodeSocket *input_socket :
node().input_sockets().drop_front(1)) {
1015 layers.append(std::move(layer_result));
1031 ntype.
ui_name =
"Cryptomatte (Legacy)";
1032 ntype.
ui_description =
"Deprecated. Use Cryptomatte Node instead";
#define NODE_STORAGE_FUNCS(StorageT)
#define CMP_NODE_CRYPTOMATTE
#define CMP_NODE_CRYPTOMATTE_LEGACY
#define BLI_SCOPED_DEFER(function_to_defer)
#define RE_PASSNAME_CRYPTOMATTE_MATERIAL
#define RE_PASSNAME_CRYPTOMATTE_ASSET
#define RE_PASSNAME_CRYPTOMATTE_OBJECT
Read Blender memory allocation and freeing.
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define BLI_assert_unreachable()
Result create_result(ResultType type, ResultPrecision precision)
gpu::Shader * get_shader(const char *info_name, ResultPrecision precision)
NodeOperation(Context &context, const bNode &node)
const bNode & node() const
Result & get_result(StringRef identifier)
void allocate_default_remaining_outputs()
Context & context() const
Result & get_input(StringRef identifier) const
virtual Domain compute_domain()
void share_data(const Result &source)
bool is_single_value() const
void unbind_as_texture_or_single_value(gpu::Texture *single_value_texture) const
void store_pixel(const int2 &texel, const T &pixel_value)
bool should_compute() const
void allocate_texture(const Domain domain, const bool from_pool=true, const std::optional< ResultStorageType > storage_type=std::nullopt)
void unbind_as_texture() const
static ResultType type(gpu::TextureFormat format)
void bind_as_texture(gpu::Shader *shader, const char *texture_name) const
void set_precision(ResultPrecision precision)
T load_pixel(const int2 &texel) const
void unbind_as_image() const
static ResultPrecision precision(gpu::TextureFormat format)
void bind_as_image(gpu::Shader *shader, const char *image_name, bool read=false) const
gpu::Texture * bind_as_texture_or_single_value(gpu::Shader *shader, const char *texture_name) const
StructureType structure_type
ColorGeometry4f default_value
NodeOperation(Context &context, const bNode &node)
void compute_pick_gpu(const Vector< Result > &layers)
Vector< float > get_identifiers()
void compute_pick_cpu(const Vector< Result > &layers)
Result compute_matte_gpu(const Vector< Result > &layers)
void compute_image_gpu(const Result &matte)
Vector< Span< float > > get_identifiers_slices(const Vector< float > &identifiers)
Result compute_matte(const Vector< Result > &layers)
virtual Vector< Result > get_layers()=0
virtual Result & get_input_image()=0
void compute_image(const Result &matte)
void compute_image_cpu(const Result &matte)
void compute_pick(const Vector< Result > &layers)
Result compute_matte_cpu(const Vector< Result > &layers)
std::string get_combined_layer_pass_name(RenderLayer *render_layer, RenderPass *render_pass)
Vector< Result > get_layers_from_image()
Result & get_input_image() override
std::string get_type_name()
ImageUser get_image_user()
Domain compute_domain() override
CMPNodeCryptomatteSource get_source()
Domain compute_image_domain()
Vector< Result > get_layers_from_render()
Vector< Result > get_layers() override
Result & get_input_image() override
Vector< Result > get_layers() override
#define storage(slot, qualifiers)
bool is_viewport_compositor_used(const bContext &context)
std::unique_ptr< CryptomatteSession, CryptomatteSessionDeleter > CryptomatteSessionPtr
const Vector< std::string > & BKE_cryptomatte_layer_names_get(const CryptomatteSession &session)
void node_register_type(bNodeType &ntype)
void node_type_storage(bNodeType &ntype, std::optional< StringRefNull > storagename, void(*freefunc)(bNode *node), void(*copyfunc)(bNodeTree *dest_ntree, bNode *dest_node, const bNode *src_node))
void compute_dispatch_threads_at_least(gpu::Shader *shader, int2 threads_range, int2 local_size=int2(16))
void parallel_for(const int2 range, const Function &function)
bool is_socket_available(const bNodeSocket *socket)
static void node_copy_cryptomatte(bNodeTree *, bNode *dest_node, const bNode *src_node)
static void node_free_cryptomatte(bNode *node)
static void node_register()
static void node_init(bNodeTree *, bNode *node)
static void node_extra_info(NodeExtraInfoParams ¶meters)
static void node_update(bNodeTree *, bNode *node)
static NodeOperation * get_compositor_operation(Context &context, const bNode &node)
static void node_init_api(const bContext *C, PointerRNA *node_ptr)
static void node_declare(NodeDeclarationBuilder &b)
static void node_declare(NodeDeclarationBuilder &b)
static void node_init(bNodeTree *, bNode *node)
static NodeOperation * get_compositor_operation(Context &context, const bNode &node)
static void node_register()
static void cryptomatte_remove(NodeCryptomatte &n, float encoded_hash)
void BKE_image_user_frame_calc(Image *ima, ImageUser *iuser, int cfra)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
RenderResult * BKE_image_acquire_renderresult(Scene *scene, Image *ima)
bool BKE_cryptomatte_find_name(const struct CryptomatteSession *session, float encoded_hash, char *r_name, int name_maxncpy)
static void cryptomatte_add(bNode &node, NodeCryptomatte &node_cryptomatte, float encoded_hash)
static bke::cryptomatte::CryptomatteSessionPtr cryptomatte_init_from_node_image(const bNode &node)
void BKE_image_release_renderresult(Scene *scene, Image *ima, RenderResult *render_result)
void void void void void void BLI_duplicatelist(ListBase *dst, const ListBase *src) ATTR_NONNULL(1
struct CryptomatteSession * BKE_cryptomatte_init_from_scene(const struct Scene *scene, bool build_meta_data)
char * BLI_strncpy_utf8(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
void GPU_shader_uniform_1f_array(gpu::Shader *sh, const char *name, int len, const float *val)
static bke::cryptomatte::CryptomatteSessionPtr cryptomatte_init_from_node(const bNode &node, const bool build_meta_data)
const char * RE_engine_id_BLENDER_EEVEE
CryptomatteSession * ntreeCompositCryptomatteSession(bNode *node)
bool ntreeCompositCryptomatteRemoveSocket(bNode *node)
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
void ntreeCompositCryptomatteAddSocket(bNode *node)
static CryptomatteEntry * cryptomatte_find(const NodeCryptomatte &n, float encoded_hash)
void ntreeCompositCryptomatteLayerPrefix(const bNode *node, char *r_prefix, size_t prefix_maxncpy)
SpaceNode * CTX_wm_space_node(const bContext *C)
void GPU_shader_bind(gpu::Shader *shader, const gpu::shader::SpecializationConstants *constants_state=nullptr)
void GPU_shader_uniform_1i(gpu::Shader *sh, const char *name, int value)
MINLINE void zero_v3(float r[3])
void ntreeCompositCryptomatteSyncFromRemove(bNode *node)
ImBuf * BKE_image_acquire_ibuf(Image *ima, ImageUser *iuser, void **r_lock)
static bke::cryptomatte::CryptomatteSessionPtr cryptomatte_init_from_node_render(const bNode &node, const bool build_meta_data)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
@ IMA_USER_FRAME_IN_RANGE
void GPU_texture_clear(gpu::Texture *texture, eGPUDataFormat data_format, const void *data)
ID_Type GS(const char *name)
void ntreeCompositCryptomatteSyncFromAdd(bNode *node)
Scene * CTX_data_scene(const bContext *C)
int BKE_image_sequence_guess_offset(Image *image)
void ntreeCompositCryptomatteUpdateLayerNames(bNode *node)
@ CMP_NODE_CRYPTOMATTE_SOURCE_IMAGE
@ CMP_NODE_CRYPTOMATTE_SOURCE_RENDER
struct CryptomatteSession * BKE_cryptomatte_init_from_render_result(const struct RenderResult *render_result)
void BKE_image_release_ibuf(Image *ima, ImBuf *ibuf, void *lock)
void cmp_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
ListBaseT< CryptomatteLayer > layers
ListBaseT< CryptomatteEntry > entries
NodeCryptomatte_Runtime runtime
ListBaseT< RenderPass > passes
ListBaseT< RenderLayer > layers
ListBaseT< ViewLayer > view_layers
static constexpr int _240
std::string ui_description
void(*) updatefunc(bNodeTree *ntree, bNode *node)
void(*) initfunc_api(const bContext *C, PointerRNA *ptr)
NodeGetCompositorOperationFunction get_compositor_operation
NodeExtraInfoFunction get_extra_info
void(*) initfunc(bNodeTree *ntree, bNode *node)
const char * enum_name_legacy
NodeGatherSocketLinkOperationsFunction gather_link_search_ops
NodeDeclareFunction declare