34 #include <string_view>
47 std::optional<std::string>
operator[](
float encoded_hash)
const;
49 #ifdef WITH_CXX_GUARDEDALLOC
50 MEM_CXX_CLASS_ALLOC_FUNCS(
"cryptomatte:CryptomatteSession")
91 if (cryptoflags == 0) {
118 std::optional<std::string>
result = layer[encoded_hash];
163 const char *layer_name,
172 const char *layer_name,
184 const char *layer_name,
187 const Object *asset_object = object;
188 while (asset_object->
parent !=
nullptr) {
189 asset_object = asset_object->
parent;
200 const float encoded_hash,
204 std::optional<std::string> name = (*session)[encoded_hash];
221 if (
BLI_strnlen(entry->name,
sizeof(entry->name)) != 0) {
238 if (matte_id ==
nullptr) {
250 std::istringstream ss(matte_id);
254 getline(ss, token,
',');
256 if (token.length() > 0) {
257 size_t first = token.find_first_not_of(
' ');
258 size_t last = token.find_last_not_of(
' ');
259 if (first == std::string::npos || last == std::string::npos) {
262 token = token.substr(first, (last - first + 1));
263 if (*token.begin() ==
'<' && *(--token.end()) ==
'>') {
264 float encoded_hash = atof(token.substr(1, token.length() - 2).c_str());
265 entry = MEM_cnew<CryptomatteEntry>(__func__);
269 const char *name = token.c_str();
270 int name_len = token.length();
271 entry = MEM_cnew<CryptomatteEntry>(__func__);
277 if (entry !=
nullptr) {
286 std::stringstream stream;
287 const size_t view_layer_name_len =
BLI_strnlen(view_layer->
name,
sizeof(view_layer->
name));
288 stream << std::string(view_layer->
name, view_layer_name_len) <<
"." << cryptomatte_layer_name;
317 const std::string manifest = layer.
manifest();
343 bool skip_next =
false;
345 char current_char = ref[
len];
350 if (current_char ==
'\\') {
353 if (current_char ==
'\"') {
365 std::ostringstream stream;
383 char front = ref.
front();
387 const int name_len = quoted_name_len - 2;
395 char colon = ref.
front();
407 if (quoted_hash_len < 2) {
410 const int hash_len = quoted_hash_len - 2;
415 else if (front ==
',') {
418 else if (front ==
'}') {
435 std::stringstream manifest;
437 bool is_first =
true;
447 manifest << quoted(item.key) <<
":\"" << (item.value.hex_encoded()) <<
"\"";
450 return manifest.str();
463 std::stringstream stream;
466 << render_pass_identifier;
467 return stream.str().substr(0, 7);
478 while (last_token > 0 && std::isdigit(render_pass_name[last_token - 1])) {
481 return render_pass_name.
substr(0, last_token);
502 std::stringstream encoded;
504 return encoded.str();
513 exponent = exponent << 23;
518 memcpy(&f, &float_bits,
sizeof(
uint32_t));
525 std::unique_ptr<CryptomatteLayer> layer = std::make_unique<CryptomatteLayer>();
532 const char *name = &
id.name[2];
538 return cryptohash_int;
543 hashes.add_overwrite(name, cryptomatte_hash);
551 return std::make_optional(item.key);
574 if (end_index <= start_index) {
577 return key.
substr(start_index + 1, end_index - start_index - 1);
581 const char *propname,
595 data->hash_to_layer_name.add(layer_hash, propvalue);
599 const char *propname,
613 if (!
data->hash_to_layer_name.contains(layer_hash)) {
void BKE_render_result_stamp_data(struct RenderResult *rr, const char *key, const char *value)
void BKE_stamp_info_callback(void *data, struct StampData *stamp_data, StampCallback callback, bool noskip)
A dynamically sized string ADT.
DynStr * BLI_dynstr_new(void) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
void BLI_dynstr_nappend(DynStr *__restrict ds, const char *cstr, int len) ATTR_NONNULL()
char * BLI_dynstr_get_cstring(const DynStr *ds) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void BLI_dynstr_free(DynStr *ds) ATTR_NONNULL()
void BLI_dynstr_appendf(DynStr *__restrict ds, const char *__restrict format,...) ATTR_PRINTF_FORMAT(2
void BLI_dynstr_append(DynStr *__restrict ds, const char *cstr) ATTR_NONNULL()
uint32_t BLI_hash_mm3(const unsigned char *data, size_t len, uint32_t seed)
BLI_INLINE bool BLI_listbase_is_empty(const struct ListBase *lb)
#define LISTBASE_FOREACH(type, var, list)
void void BLI_freelistN(struct ListBase *listbase) ATTR_NONNULL(1)
void BLI_addtail(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
#define STRNCPY(dst, src)
size_t BLI_strnlen(const char *str, size_t maxlen) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
char * BLI_strncpy(char *__restrict dst, const char *__restrict src, size_t maxncpy) ATTR_NONNULL()
eViewLayerCryptomatteFlags
@ VIEW_LAYER_CRYPTOMATTE_MATERIAL
@ VIEW_LAYER_CRYPTOMATTE_ASSET
@ VIEW_LAYER_CRYPTOMATTE_OBJECT
#define VIEW_LAYER_CRYPTOMATTE_ALL
Object is a sort of wrapper for general info.
Read Guarded memory(de)allocation.
ValueIterator values() const
Value & lookup_or_add_default(const Key &key)
ItemIterator items() const
const Value * lookup_ptr(const Key &key) const
constexpr const char & front() const
static constexpr int64_t not_found
constexpr int64_t find_last_of(StringRef chars, int64_t pos=INT64_MAX) const
constexpr int64_t find_first_not_of(StringRef chars, int64_t pos=0) const
constexpr bool is_empty() const
constexpr StringRef substr(int64_t start, int64_t size) const
constexpr bool startswith(StringRef prefix) const
constexpr bool endswith(StringRef suffix) const
constexpr int64_t find_first_of(StringRef chars, int64_t pos=0) const
constexpr int64_t size() const
constexpr const char * data() const
constexpr StringRef drop_prefix(int64_t n) const
bool contains(const T &value) const
void append(const T &value)
void BKE_cryptomatte_add_layer(struct CryptomatteSession *session, const char *layer_name)
CryptomatteSession * BKE_cryptomatte_init()
uint32_t BKE_cryptomatte_hash(const char *name, const int name_len)
static void add_render_result_meta_data(RenderResult *render_result, const blender::StringRef layer_name, const blender::StringRefNull key_name, const blender::StringRefNull value)
struct CryptomatteSession * BKE_cryptomatte_init_from_render_result(const struct RenderResult *render_result)
void BKE_cryptomatte_free(CryptomatteSession *session)
float BKE_cryptomatte_hash_to_float(uint32_t cryptomatte_hash)
char * BKE_cryptomatte_entries_to_matte_id(NodeCryptomatte *node_storage)
void BKE_cryptomatte_store_metadata(const struct CryptomatteSession *session, RenderResult *render_result, const ViewLayer *view_layer)
struct CryptomatteSession * BKE_cryptomatte_init_from_scene(const struct Scene *scene)
uint32_t BKE_cryptomatte_asset_hash(CryptomatteSession *session, const char *layer_name, const Object *object)
static uint32_t cryptomatte_determine_identifier(const blender::StringRef name)
bool BKE_cryptomatte_find_name(const CryptomatteSession *session, const float encoded_hash, char *r_name, int name_len)
void BKE_cryptomatte_matte_id_to_entries(NodeCryptomatte *node_storage, const char *matte_id)
uint32_t BKE_cryptomatte_object_hash(CryptomatteSession *session, const char *layer_name, const Object *object)
static std::string cryptomatte_determine_name(const ViewLayer *view_layer, const blender::StringRefNull cryptomatte_layer_name)
uint32_t BKE_cryptomatte_material_hash(CryptomatteSession *session, const char *layer_name, const Material *material)
smooth(Type::VEC4, "color_mul") .smooth(Type gpFillTexture gpSceneDepthTexture materials[GPENCIL_MATERIAL_BUFFER_LEN]
void *(* MEM_dupallocN)(const void *vmemh)
static bool from_manifest(CryptomatteLayer &layer, blender::StringRefNull manifest)
static constexpr int quoted_string_len_(blender::StringRef ref)
constexpr StringRef WHITESPACES
static std::string unquote_(const blender::StringRef ref)
static constexpr blender::StringRef skip_whitespaces_(blender::StringRef ref)
static std::string to_manifest(const CryptomatteLayer *layer)
StringRef BKE_cryptomatte_extract_layer_name(const StringRef render_pass_name)
std::string BKE_cryptomatte_meta_data_key(const StringRef layer_name, const StringRefNull key_name)
static std::string cryptomatte_layer_name_hash(const StringRef layer_name)
const blender::Vector< std::string > & BKE_cryptomatte_layer_names_get(const CryptomatteSession &session)
CryptomatteSession()=default
blender::Map< std::string, blender::bke::cryptomatte::CryptomatteLayer > layers
std::optional< std::string > operator[](float encoded_hash) const
blender::bke::cryptomatte::CryptomatteLayer & add_layer(std::string layer_name)
blender::Vector< std::string > layer_names
struct StampData * stamp_data
static CryptomatteHash from_hex_encoded(blender::StringRef hex_encoded)
CryptomatteHash(uint32_t hash)
std::string hex_encoded() const
float float_encoded() const
void add_hash(blender::StringRef name, CryptomatteHash cryptomatte_hash)
blender::Map< std::string, CryptomatteHash > hashes
static std::unique_ptr< CryptomatteLayer > read_from_manifest(blender::StringRefNull manifest)
std::optional< std::string > operator[](float encoded_hash) const
std::string manifest() const
uint32_t add_ID(const struct ID &id)
static void extract_layer_names(void *_data, const char *propname, char *propvalue, int len)
static blender::StringRef extract_layer_hash(blender::StringRefNull key)
static void extract_layer_manifest(void *_data, const char *propname, char *propvalue, int len)
struct CryptomatteSession * session
static const char hex[17]