71 const ListBaseT<RenderLayer> *layers = &render_result->
layers;
122 if (!render_result) {
126 const ListBaseT<RenderView> *views = &render_result->
views;
132 const int view = image_user.
view;
141 const char *view_name = context.get_view_name().data();
145 if (matched_view == -1) {
161 const char *pass_name)
163 ImageUser image_user_for_pass = image_user;
166 image_user_for_pass.
view =
get_view_index(context, render_result, image_user_for_pass);
170 image_user_for_pass.
pass =
get_pass_index(render_result, image_user_for_pass, pass_name);
177 return image_user_for_pass;
200 linear_image_buffer->
flags = image_buffer->
flags;
217 const bool is_suitable_compressed_color_space =
225 return linear_image_buffer;
231 switch (channels_count) {
284 const char *pass_name)
296 if (!initial_image_buffer) {
303 context,
image, render_result, image_user, pass_name);
316 this->populate_cryptomatte_meta_data(render_result, image_user_for_pass);
323 this->populate_meta_data(image_buffer);
333 if (context.use_gpu()) {
340 const int2 size =
int2(image_buffer->
x, image_buffer->
y);
372void CachedImage::populate_cryptomatte_meta_data(
const RenderResult *render_result,
375 if (!render_result) {
384 const RenderPass *render_pass =
get_render_pass(render_layer, image_user);
391 const bool is_named_layer = render_layer->
name[0] !=
'\0';
392 const std::string layer_prefix = is_named_layer ? std::string(render_layer->
name) +
"." :
"";
393 const std::string combined_pass_name = layer_prefix + render_pass->name;
397 struct StampCallbackData {
398 std::string cryptomatte_layer_name;
399 compositor::MetaData *meta_data;
403 StampCallbackData callback_data = {cryptomatte_layer_name, &this->
result.
meta_data};
407 [](
void *user_data,
const char *key,
char *value,
int ) {
408 StampCallbackData *data = static_cast<StampCallbackData *>(user_data);
410 const std::string manifest_key = bke::cryptomatte::BKE_cryptomatte_meta_data_key(
411 data->cryptomatte_layer_name,
"manifest");
412 if (key == manifest_key) {
413 data->meta_data->cryptomatte.manifest = value;
417 data->cryptomatte_layer_name,
"hash");
419 data->meta_data->cryptomatte.hash = value;
423 data->cryptomatte_layer_name,
"conversion");
424 if (key == conversion_key) {
425 data->meta_data->cryptomatte.conversion = value;
431void CachedImage::populate_meta_data(
const ImBuf *image_buffer)
435 [](
const char *key,
const char *value,
void *user_data) {
455 for (
auto &cached_images_for_id : map_.values()) {
456 cached_images_for_id.remove_if([](
auto item) {
return !item.value->needed; });
458 map_.remove_if([](
auto item) {
return item.value.is_empty(); });
459 update_counts_.remove_if([&](
auto item) {
return !map_.contains(item.key); });
463 for (
auto &cached_images_for_id : map_.values()) {
464 for (
auto &value : cached_images_for_id.values()) {
465 value->needed =
false;
473 const char *pass_name)
476 ImageUser image_user_for_frame = image_user;
483 const std::string view_name = image_user.
view == 0 ? std::string(context.get_view_name()) :
484 std::to_string(image_user.
view);
488 const std::string library_key =
image.id.lib ?
image.id.lib->id.name :
"";
489 const std::string id_key = std::string(
image.id.name) + library_key;
490 auto &cached_images_for_id = map_.lookup_or_add_default(id_key);
493 if (!cached_images_for_id.is_empty() &&
494 image.runtime->update_count != update_counts_.lookup(id_key))
496 cached_images_for_id.clear();
499 auto &cached_image = *cached_images_for_id.lookup_or_add_cb(key, [&]() {
500 return std::make_unique<CachedImage>(context,
image, image_user_for_frame, pass_name);
504 update_counts_.add_overwrite(id_key,
image.runtime->update_count);
506 cached_image.needed =
true;
507 return cached_image.result;
ID and Library types, which are fundamental for SDNA.
#define GPU_TEXTURE_FREE_SAFE(texture)
#define BLI_assert_unreachable()
bool add(const Key &key, const Value &value)
Result & get(Context &context, Image &image, const ImageUser &image_user, const char *pass_name)
CachedImageKey(const int layer_index, const std::string pass_name, const std::string view_name, const int frame)
const std::string view_name
const std::string pass_name
CachedImage(Context &context, Image &image, ImageUser &image_user, const char *pass_name)
void share_data(const Result &source)
void store_pixel(const int2 &texel, const T &pixel_value)
void allocate_texture(const Domain domain, const bool from_pool=true, const std::optional< ResultStorageType > storage_type=std::nullopt)
void set_precision(ResultPrecision precision)
void transform(const float3x3 &transformation)
T load_pixel(const int2 &texel) const
void set_type(ResultType type)
StringRef BKE_cryptomatte_extract_layer_name(StringRef render_pass_name)
std::string BKE_cryptomatte_meta_data_key(StringRef layer_name, StringRefNull key_name)
static ImageUser compute_image_user_for_pass(const Context &context, const Image &image, const RenderResult *render_result, const ImageUser &image_user, const char *pass_name)
static ResultType float_type(const int channels_count)
ColorSceneLinear4f< eAlpha::Premultiplied > Color
bool operator==(const BokehKernelKey &a, const BokehKernelKey &b)
static ImBuf * compute_linear_buffer(ImBuf *image_buffer)
static ResultType get_pass_type(const RenderPass *render_pass)
static int get_pass_index(const RenderResult *render_result, const ImageUser &image_user, const char *name)
static RenderPass * get_render_pass(const RenderLayer *render_layer, const ImageUser &image_user)
static int get_view_index(const Context &context, const RenderResult *render_result, const ImageUser &image_user)
static RenderLayer * get_render_layer(const RenderResult *render_result, const ImageUser &image_user)
void parallel_for(const int2 range, const Function &function)
MatT from_location(const typename MatT::loc_type &location)
void BKE_image_user_frame_calc(Image *ima, ImageUser *iuser, int cfra)
RenderResult * BKE_image_acquire_renderresult(Scene *scene, Image *ima)
unsigned __int64 uint64_t
void BKE_image_multiview_index(const Image *ima, ImageUser *iuser)
void BKE_image_release_renderresult(Scene *scene, Image *ima, RenderResult *render_result)
void IMB_float_from_byte(ImBuf *ibuf)
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
bool IMB_colormanagement_space_is_scene_linear(const ColorSpace *colorspace)
int BLI_findstringindex(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void IMB_freeImBuf(ImBuf *ibuf)
RenderPass * BKE_image_multilayer_index(RenderResult *rr, ImageUser *iuser)
BMesh const char void * data
int BLI_listbase_count_at_most(const ListBase *listbase, int count_max) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
ImBuf * IMB_allocImBuf(unsigned int x, unsigned int y, ImBufFlags flags)
ImBuf * BKE_image_acquire_ibuf(Image *ima, ImageUser *iuser, void **r_lock)
bool IMB_colormanagement_space_is_data(const ColorSpace *colorspace)
void BKE_stamp_info_callback(void *data, StampData *stamp_data, StampCallback callback, bool noskip)
gpu::Texture * IMB_create_gpu_texture(const char *name, ImBuf *ibuf, GPUTextureCreateFlags flags)
void IMB_metadata_foreach(const ImBuf *ibuf, IMBMetadataForeachCb callback, void *userdata)
constexpr uint64_t get_default_hash(const T &v, const Args &...args)
bool BKE_image_is_multilayer(const Image *ima)
void BKE_image_release_ibuf(Image *ima, ImBuf *ibuf, void *lock)
const ColorSpace * colorspace
ImplicitSharingPtr sharing_info
ImbFormatOptions foptions
ImBufFloatBuffer float_buffer
ImBufByteBuffer byte_buffer
const float * float_data() const
ListBaseT< RenderPass > passes
struct StampData * stamp_data
ListBaseT< RenderView > views
ListBaseT< RenderLayer > layers