50 void init(
const ViewLayer *view_layer,
bool build_meta_data =
false);
53 std::optional<std::string>
operator[](
float encoded_hash)
const;
55 MEM_CXX_CLASS_ALLOC_FUNCS(
"cryptomatte:CryptomatteSession")
60 if (!bmain->
objects.is_empty()) {
69 while (asset_object->
parent !=
nullptr) {
70 asset_object = asset_object->
parent;
78 materials.
add_ID(material.id);
107 if (build_meta_data) {
110 init(&view_layer, build_meta_data);
118 if (cryptoflags == 0) {
130 if (build_meta_data) {
131 for (
Base &base : *object_bases) {
132 objects.
add_ID(base.object->id);
141 if (build_meta_data) {
142 for (
Base &base : *object_bases) {
143 const Object *asset_object = base.object;
144 while (asset_object->
parent !=
nullptr) {
145 asset_object = asset_object->
parent;
156 if (build_meta_data) {
157 for (
Base &base : *object_bases) {
158 for (
int i = 0; i < base.object->totcol; i++) {
161 materials.
add_ID(material->id);
174 return layers.lookup_or_add_default(layer_name);
180 std::optional<std::string>
result =
layer[encoded_hash];
230 const char *layer_name,
239 const char *layer_name,
242 if (material ==
nullptr) {
247 return layer->add_ID(material->id);
251 const char *layer_name,
255 while (asset_object->
parent !=
nullptr) {
256 asset_object = asset_object->
parent;
267 const float encoded_hash,
271 std::optional<std::string> name = (*session)[encoded_hash];
288 if (entry.
name[0] !=
'\0') {
303 node_storage->
entries.free_no_destruct();
305 if (matte_id ==
nullptr) {
306 MEM_SAFE_DELETE(node_storage->
matte_id);
314 MEM_SAFE_DELETE(node_storage->
matte_id);
315 node_storage->
matte_id = MEM_dupalloc(matte_id);
318 std::istringstream ss(matte_id);
322 getline(ss, token,
',');
324 if (!token.empty()) {
325 size_t first = token.find_first_not_of(
' ');
326 size_t last = token.find_last_not_of(
' ');
327 if (first == std::string::npos || last == std::string::npos) {
330 token = token.substr(first, (last - first + 1));
331 if (*token.begin() ==
'<' && *(--token.end()) ==
'>') {
332 float encoded_hash = atof(token.substr(1, token.length() - 2).c_str());
333 entry = MEM_new<CryptomatteEntry>(__func__);
337 const char *name = token.c_str();
338 int name_len = token.length();
339 entry = MEM_new<CryptomatteEntry>(__func__);
345 if (entry !=
nullptr) {
375 const std::string manifest =
layer.manifest();
384namespace bke::cryptomatte {
400 bool skip_next =
false;
402 char current_char = ref[
len];
407 if (current_char ==
'\\') {
410 if (current_char ==
'\"') {
422 std::ostringstream stream;
440 char front = ref.
front();
444 const int name_len = quoted_name_len - 2;
452 char colon = ref.
front();
464 if (quoted_hash_len < 2) {
467 const int hash_len = quoted_hash_len - 2;
472 else if (front ==
',') {
475 else if (front ==
'}') {
494 bool is_first =
true;
504 manifest << quoted(item.key) <<
":\"" << item.value.hex_encoded() <<
"\"";
520 std::stringstream stream;
522 stream << std::setfill(
'0') << std::setw(
sizeof(
uint32_t) * 2) << std::hex
523 << render_pass_identifier;
524 return stream.str().substr(0, 7);
535 while (last_token > 0 && std::isdigit(render_pass_name[last_token - 1])) {
538 return render_pass_name.
substr(0, last_token);
552 std::stringstream encoded;
553 encoded << std::setfill(
'0') << std::setw(
sizeof(
uint32_t) * 2) << std::hex <<
hash;
554 return encoded.str();
559 std::unique_ptr<CryptomatteLayer>
layer = std::make_unique<CryptomatteLayer>();
566 const char *name = &
id.name[2];
572 return cryptohash_int;
577 hashes.add_overwrite(name, cryptomatte_hash);
585 return std::make_optional(item.key);
608 if (end_index <= start_index) {
611 return key.
substr(start_index + 1, end_index - start_index - 1);
615 const char *propname,
629 data->hash_to_layer_name.add(layer_hash, propvalue);
633 const char *propname,
647 if (!
data->hash_to_layer_name.contains(layer_hash)) {
651 StringRef layer_name =
data->hash_to_layer_name.lookup(layer_hash);
663 return session.
layers.lookup_ptr(layer_name);
General operations, lookup, etc. for materials.
A dynamically sized string ADT.
#define VIEW_LAYER_CRYPTOMATTE_ALL
Object is a sort of wrapper for general info.
#define RE_PASSNAME_CRYPTOMATTE_MATERIAL
#define RE_PASSNAME_CRYPTOMATTE_ASSET
#define RE_PASSNAME_CRYPTOMATTE_OBJECT
Read Blender memory allocation and freeing.
ItemIterator items() const &
constexpr StringRefNull()
constexpr StringRef drop_prefix(int64_t n) const
constexpr int64_t find_first_of(StringRef chars, int64_t pos=0) const
constexpr const char & front() const
constexpr bool startswith(StringRef prefix) const
static constexpr int64_t not_found
constexpr bool is_empty() const
constexpr int64_t size() const
constexpr int64_t find_first_not_of(StringRef chars, int64_t pos=0) const
constexpr StringRef substr(int64_t start, int64_t size) const
constexpr const char * data() const
constexpr int64_t find_last_of(StringRef chars, int64_t pos=INT64_MAX) const
constexpr bool endswith(StringRef suffix) const
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
constexpr StringRef WHITESPACES
static constexpr StringRef skip_whitespaces_(StringRef ref)
static std::string unquote_(const StringRef ref)
static std::string to_manifest(const CryptomatteLayer *layer)
static bool from_manifest(CryptomatteLayer &layer, StringRefNull manifest)
static constexpr int quoted_string_len_(StringRef ref)
StringRef BKE_cryptomatte_extract_layer_name(StringRef render_pass_name)
const Vector< std::string > & BKE_cryptomatte_layer_names_get(const CryptomatteSession &session)
CryptomatteLayer * BKE_cryptomatte_layer_get(CryptomatteSession &session, StringRef layer_name)
static std::string cryptomatte_layer_name_hash(const StringRef layer_name)
std::string BKE_cryptomatte_meta_data_key(StringRef layer_name, StringRefNull key_name)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
bool BKE_cryptomatte_find_name(const struct CryptomatteSession *session, float encoded_hash, char *r_name, int name_maxncpy)
void BLI_dynstr_appendf(DynStr *__restrict ds, const char *__restrict format,...) ATTR_PRINTF_FORMAT(2
static void add_render_result_meta_data(RenderResult *render_result, const StringRef layer_name, const StringRefNull key_name, const StringRefNull value)
char * STRNCPY(char(&dst)[N], const char *src)
void BLI_dynstr_nappend(DynStr *__restrict ds, const char *cstr, int len) ATTR_NONNULL()
uint32_t BLI_hash_mm3(const unsigned char *data, size_t len, uint32_t seed)
struct CryptomatteSession * BKE_cryptomatte_init()
Material * BKE_object_material_get(Object *ob, short act)
struct CryptomatteSession * BKE_cryptomatte_init_from_scene(const struct Scene *scene, bool build_meta_data)
void BKE_render_result_stamp_data(RenderResult *rr, const char *key, const char *value)
static uint32_t cryptomatte_determine_identifier(const StringRef name)
char * BLI_strncpy_utf8(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
uint32_t BKE_cryptomatte_hash(const char *name, int name_len)
void BLI_dynstr_free(DynStr *ds) ATTR_NONNULL()
void BKE_cryptomatte_store_metadata(const struct CryptomatteSession *session, struct RenderResult *render_result)
void BLI_dynstr_append(DynStr *__restrict ds, const char *cstr) ATTR_NONNULL()
struct CryptomatteSession * BKE_cryptomatte_init_from_view_layer(const struct ViewLayer *view_layer)
BMesh const char void * data
void BKE_cryptomatte_add_layer(struct CryptomatteSession *session, const char *layer_name)
bool BKE_view_layer_is_synced(const ViewLayer &view_layer)
int char char int int int int size_t BLI_strnlen(const char *str, size_t maxlen) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
char * BLI_dynstr_get_cstring(const DynStr *ds) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
uint32_t BKE_cryptomatte_material_hash(struct CryptomatteSession *session, const char *layer_name, const struct Material *material)
void BKE_stamp_info_callback(void *data, StampData *stamp_data, StampCallback callback, bool noskip)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
char * BKE_cryptomatte_entries_to_matte_id(struct NodeCryptomatte *node_storage)
eViewLayerCryptomatteFlags
@ VIEW_LAYER_CRYPTOMATTE_ASSET
@ VIEW_LAYER_CRYPTOMATTE_MATERIAL
@ VIEW_LAYER_CRYPTOMATTE_OBJECT
uint32_t BKE_cryptomatte_object_hash(struct CryptomatteSession *session, const char *layer_name, const struct Object *object)
float BKE_cryptomatte_hash_to_float(uint32_t cryptomatte_hash)
struct CryptomatteSession * BKE_cryptomatte_init_from_render_result(const struct RenderResult *render_result)
DynStr * BLI_dynstr_new() ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
void BKE_cryptomatte_free(struct CryptomatteSession *session)
ListBaseT< Base > * BKE_view_layer_object_bases_get(ViewLayer *view_layer)
void BKE_cryptomatte_matte_id_to_entries(struct NodeCryptomatte *node_storage, const char *matte_id)
uint32_t BKE_cryptomatte_asset_hash(struct CryptomatteSession *session, const char *layer_name, const struct Object *object)
Map< std::string, bke::cryptomatte::CryptomatteLayer > layers
void init(const ViewLayer *view_layer, bool build_meta_data=false)
Vector< std::string > layer_names
bke::cryptomatte::CryptomatteLayer & add_layer(std::string layer_name)
std::optional< std::string > operator[](float encoded_hash) const
CryptomatteSession()=default
ListBaseT< Material > materials
ListBaseT< Object > objects
ListBaseT< CryptomatteEntry > entries
struct StampData * stamp_data
ListBaseT< ViewLayer > view_layers
eViewLayerCryptomatteFlags cryptomatte_flag
static CryptomatteHash from_hex_encoded(StringRef hex_encoded)
CryptomatteHash(uint32_t hash)
std::string hex_encoded() const
float float_encoded() const
uint32_t add_ID(const ID &id)
Map< std::string, CryptomatteHash > hashes
std::optional< std::string > operator[](float encoded_hash) const
std::string manifest() const
static std::unique_ptr< CryptomatteLayer > read_from_manifest(StringRefNull manifest)
void add_hash(StringRef name, CryptomatteHash cryptomatte_hash)
static void extract_layer_manifest(void *_data, const char *propname, char *propvalue, int propvalue_maxncpy)
static StringRef extract_layer_hash(StringRefNull key)
static void extract_layer_names(void *_data, const char *propname, char *propvalue, int propvalue_maxncpy)
CryptomatteSession * session