Blender  V3.3
eevee_cryptomatte.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2020 Blender Foundation. */
3 
31 #include "DRW_engine.h"
32 #include "DRW_render.h"
33 
34 #include "BKE_cryptomatte.h"
35 
36 #include "GPU_batch.h"
37 
38 #include "RE_pipeline.h"
39 
40 #include "BLI_alloca.h"
41 #include "BLI_math_bits.h"
42 #include "BLI_rect.h"
43 
44 #include "DNA_curves_types.h"
45 #include "DNA_mesh_types.h"
46 #include "DNA_modifier_types.h"
47 #include "DNA_particle_types.h"
48 
49 #include "eevee_private.h"
50 
51 /* -------------------------------------------------------------------- */
56 {
57  const eViewLayerCryptomatteFlags cryptomatte_layers = view_layer->cryptomatte_flag &
59  return cryptomatte_layers;
60 }
61 
62 /* The number of cryptomatte layers that are enabled */
64 {
66  view_layer);
67  return count_bits_i(cryptomatte_layers);
68 }
69 
70 /* The number of render result passes are needed to store a single cryptomatte layer. Per
71  * render-pass 2 cryptomatte samples can be stored. */
73 {
74  const int num_cryptomatte_levels = view_layer->cryptomatte_levels;
75  const int num_cryptomatte_passes = (num_cryptomatte_levels + 1) / 2;
76  return num_cryptomatte_passes;
77 }
78 
80 {
81  return view_layer->cryptomatte_levels;
82 }
83 
84 BLI_INLINE int eevee_cryptomatte_layer_offset(const ViewLayer *view_layer, const int layer)
85 {
86  return view_layer->cryptomatte_levels * layer;
87 }
88 
90 {
91  return eevee_cryptomatte_layer_stride(view_layer) * eevee_cryptomatte_layers_count(view_layer);
92 }
93 
96 /* -------------------------------------------------------------------- */
101 {
102  EEVEE_StorageList *stl = vedata->stl;
104 
105  const DRWContextState *draw_ctx = DRW_context_state_get();
106  ViewLayer *view_layer = draw_ctx->view_layer;
107 
108  /* Cryptomatte is only rendered for final image renders */
109  if (!DRW_state_is_scene_render()) {
110  return;
111  }
112  const eViewLayerCryptomatteFlags active_layers = eevee_cryptomatte_active_layers(view_layer);
113  if (active_layers) {
114  struct CryptomatteSession *session = BKE_cryptomatte_init();
115  if ((active_layers & VIEW_LAYER_CRYPTOMATTE_OBJECT) != 0) {
116  BKE_cryptomatte_add_layer(session, "CryptoObject");
117  }
118  if ((active_layers & VIEW_LAYER_CRYPTOMATTE_MATERIAL) != 0) {
119  BKE_cryptomatte_add_layer(session, "CryptoMaterial");
120  }
121  if ((active_layers & VIEW_LAYER_CRYPTOMATTE_ASSET) != 0) {
122  BKE_cryptomatte_add_layer(session, "CryptoAsset");
123  }
124  g_data->cryptomatte_session = session;
125 
127  g_data->cryptomatte_accurate_mode = (view_layer->cryptomatte_flag &
129  }
130 }
131 
133  EEVEE_Data *vedata,
134  int UNUSED(tot_samples))
135 {
136  EEVEE_FramebufferList *fbl = vedata->fbl;
137  EEVEE_TextureList *txl = vedata->txl;
138  EEVEE_StorageList *stl = vedata->stl;
140 
142  const DRWContextState *draw_ctx = DRW_context_state_get();
143  const ViewLayer *view_layer = draw_ctx->view_layer;
144 
145  const int num_cryptomatte_layers = eevee_cryptomatte_layers_count(view_layer);
146  eGPUTextureFormat format = (num_cryptomatte_layers == 1) ? GPU_R32F :
147  (num_cryptomatte_layers == 2) ? GPU_RG32F :
148  GPU_RGBA32F;
149  const float *viewport_size = DRW_viewport_size_get();
150  const int buffer_size = viewport_size[0] * viewport_size[1];
151 
152  if (g_data->cryptomatte_accum_buffer == NULL) {
153  g_data->cryptomatte_accum_buffer = MEM_calloc_arrayN(
154  buffer_size * eevee_cryptomatte_pixel_stride(view_layer),
155  sizeof(EEVEE_CryptomatteSample),
156  __func__);
157  /* Download buffer should store a float per active cryptomatte layer. */
158  g_data->cryptomatte_download_buffer = MEM_malloc_arrayN(
159  buffer_size * num_cryptomatte_layers, sizeof(float), __func__);
160  }
161  else {
162  /* During multiview rendering the `cryptomatte_accum_buffer` is deallocated after all views
163  * have been rendered. Clear it here to be reused by the next view. */
164  memset(g_data->cryptomatte_accum_buffer,
165  0,
166  buffer_size * eevee_cryptomatte_pixel_stride(view_layer) *
167  sizeof(EEVEE_CryptomatteSample));
168  }
169 
171  GPU_framebuffer_ensure_config(&fbl->cryptomatte_fb,
172  {
173  GPU_ATTACHMENT_TEXTURE(dtxl->depth),
174  GPU_ATTACHMENT_TEXTURE(txl->cryptomatte),
175  });
176 }
177 
180 /* -------------------------------------------------------------------- */
185 {
186  EEVEE_PassList *psl = vedata->psl;
187  if ((vedata->stl->g_data->render_passes & EEVEE_RENDER_PASS_CRYPTOMATTE) != 0) {
189  }
190 }
191 
193  EEVEE_Data *vedata, EEVEE_ViewLayerData *sldata, Object *ob, Material *material, bool is_hair)
194 {
195  const DRWContextState *draw_ctx = DRW_context_state_get();
196  const ViewLayer *view_layer = draw_ctx->view_layer;
198  view_layer);
199  EEVEE_PrivateData *g_data = vedata->stl->g_data;
200  float cryptohash[4] = {0.0f};
201 
202  EEVEE_PassList *psl = vedata->psl;
203  int layer_offset = 0;
204  if ((cryptomatte_layers & VIEW_LAYER_CRYPTOMATTE_OBJECT) != 0) {
205  uint32_t cryptomatte_hash = BKE_cryptomatte_object_hash(
206  g_data->cryptomatte_session, "CryptoObject", ob);
207  float cryptomatte_color_value = BKE_cryptomatte_hash_to_float(cryptomatte_hash);
208  cryptohash[layer_offset] = cryptomatte_color_value;
209  layer_offset++;
210  }
211  if ((cryptomatte_layers & VIEW_LAYER_CRYPTOMATTE_MATERIAL) != 0) {
212  uint32_t cryptomatte_hash = BKE_cryptomatte_material_hash(
213  g_data->cryptomatte_session, "CryptoMaterial", material);
214  float cryptomatte_color_value = BKE_cryptomatte_hash_to_float(cryptomatte_hash);
215  cryptohash[layer_offset] = cryptomatte_color_value;
216  layer_offset++;
217  }
218  if ((cryptomatte_layers & VIEW_LAYER_CRYPTOMATTE_ASSET) != 0) {
219  uint32_t cryptomatte_hash = BKE_cryptomatte_asset_hash(
220  g_data->cryptomatte_session, "CryptoAsset", ob);
221  float cryptomatte_color_value = BKE_cryptomatte_hash_to_float(cryptomatte_hash);
222  cryptohash[layer_offset] = cryptomatte_color_value;
223  layer_offset++;
224  }
225 
227  psl->cryptomatte_ps);
228  DRW_shgroup_uniform_vec4_copy(grp, "cryptohash", cryptohash);
229  DRW_shgroup_uniform_block(grp, "shadow_block", sldata->shadow_ubo);
230 
231  return grp;
232 }
233 
235  EEVEE_ViewLayerData *sldata,
236  Object *ob,
237  ParticleSystem *psys,
238  ModifierData *md,
240 {
242  vedata, sldata, ob, material, true);
243  DRW_shgroup_hair_create_sub(ob, psys, md, grp, NULL);
244 }
245 
247  EEVEE_ViewLayerData *sldata,
248  Object *ob)
249 {
250  BLI_assert(ob->type == OB_CURVES);
253  vedata, sldata, ob, material, true);
255 }
256 
258  EEVEE_ViewLayerData *sldata,
259  Object *ob)
260 {
261  const DRWContextState *draw_ctx = DRW_context_state_get();
262 
263  if (ob->type == OB_MESH) {
264  if (ob != draw_ctx->object_edit) {
265  LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
266  if (md->type != eModifierType_ParticleSystem) {
267  continue;
268  }
269  ParticleSystem *psys = ((ParticleSystemModifierData *)md)->psys;
271  continue;
272  }
273  ParticleSettings *part = psys->part;
274  const int draw_as = (part->draw_as == PART_DRAW_REND) ? part->ren_as : part->draw_as;
275  if (draw_as != PART_DRAW_PATH) {
276  continue;
277  }
279  eevee_cryptomatte_curves_cache_populate(vedata, sldata, ob, psys, md, material);
280  }
281  }
282  }
283 }
284 
286 {
287  const DRWContextState *draw_ctx = DRW_context_state_get();
288  const ViewLayer *view_layer = draw_ctx->view_layer;
290  view_layer);
291 
292  if ((cryptomatte_layers & VIEW_LAYER_CRYPTOMATTE_MATERIAL) != 0) {
293  const int materials_len = DRW_cache_object_material_count_get(ob);
294  struct GPUMaterial **gpumat_array = BLI_array_alloca(gpumat_array, materials_len);
295  memset(gpumat_array, 0, sizeof(*gpumat_array) * materials_len);
297  ob, gpumat_array, materials_len);
298  if (geoms) {
299  for (int i = 0; i < materials_len; i++) {
300  struct GPUBatch *geom = geoms[i];
301  if (geom == NULL) {
302  continue;
303  }
306  vedata, sldata, ob, material, false);
307  DRW_shgroup_call(grp, geom, ob);
308  }
309  }
310  }
311  else {
313  if (geom) {
315  vedata, sldata, ob, NULL, false);
316  DRW_shgroup_call(grp, geom, ob);
317  }
318  }
319 }
320 
323 /* -------------------------------------------------------------------- */
327 /* Downloads cryptomatte sample buffer from the GPU and integrate the samples with the accumulated
328  * cryptomatte samples. */
330 {
331  EEVEE_StorageList *stl = vedata->stl;
333  const DRWContextState *draw_ctx = DRW_context_state_get();
334  const ViewLayer *view_layer = draw_ctx->view_layer;
335  const int num_cryptomatte_layers = eevee_cryptomatte_layers_count(view_layer);
336  const int num_levels = view_layer->cryptomatte_levels;
337  const float *viewport_size = DRW_viewport_size_get();
338  const int buffer_size = viewport_size[0] * viewport_size[1];
339 
340  EEVEE_CryptomatteSample *accum_buffer = g_data->cryptomatte_accum_buffer;
341  float *download_buffer = g_data->cryptomatte_download_buffer;
342 
343  BLI_assert(accum_buffer);
344  BLI_assert(download_buffer);
345 
346  GPU_framebuffer_read_color(framebuffer,
347  0,
348  0,
349  viewport_size[0],
350  viewport_size[1],
351  num_cryptomatte_layers,
352  0,
354  download_buffer);
355 
356  /* Integrate download buffer into the accum buffer.
357  * The download buffer contains up to 3 floats per pixel (one float per cryptomatte layer.
358  *
359  * NOTE: here we deviate from the cryptomatte standard. During integration the standard always
360  * sort the samples by its weight to make sure that samples with the lowest weight
361  * are discarded first. In our case the weight of each sample is always 1 as we don't have
362  * subsamples and apply the coverage during the post processing. When there is no room for new
363  * samples the new samples has a weight of 1 and will always be discarded. */
364  int download_pixel_index = 0;
365  int accum_pixel_index = 0;
366  int accum_pixel_stride = eevee_cryptomatte_pixel_stride(view_layer);
367  for (int pixel_index = 0; pixel_index < buffer_size; pixel_index++) {
368  for (int layer = 0; layer < num_cryptomatte_layers; layer++) {
369  const int layer_offset = eevee_cryptomatte_layer_offset(view_layer, layer);
370  float download_hash = download_buffer[download_pixel_index++];
371  for (int level = 0; level < num_levels; level++) {
372  EEVEE_CryptomatteSample *sample = &accum_buffer[accum_pixel_index + layer_offset + level];
373  if (sample->hash == download_hash) {
374  sample->weight += 1.0f;
375  break;
376  }
377  /* We test against weight as hash 0.0f is used for samples hitting the world background. */
378  if (sample->weight == 0.0f) {
379  sample->hash = download_hash;
380  sample->weight = 1.0f;
381  break;
382  }
383  }
384  }
385  accum_pixel_index += accum_pixel_stride;
386  }
387 }
388 
390 {
391  EEVEE_FramebufferList *fbl = vedata->fbl;
392  EEVEE_StorageList *stl = vedata->stl;
394  EEVEE_EffectsInfo *effects = stl->effects;
395  EEVEE_PassList *psl = vedata->psl;
396  const DRWContextState *draw_ctx = DRW_context_state_get();
397  const ViewLayer *view_layer = draw_ctx->view_layer;
398  const int cryptomatte_levels = view_layer->cryptomatte_levels;
399  const int current_sample = effects->taa_current_sample;
400 
401  /* In accurate mode all render samples are evaluated. In inaccurate mode this is limited to the
402  * number of cryptomatte levels. This will reduce the overhead of downloading the GPU buffer and
403  * integrating it into the accum buffer. */
404  if (g_data->cryptomatte_accurate_mode || current_sample < cryptomatte_levels) {
405  static float clear_color[4] = {0.0};
407  GPU_framebuffer_clear_color(fbl->cryptomatte_fb, clear_color);
409 
411 
412  /* Restore */
414  }
415 }
416 
419 /* -------------------------------------------------------------------- */
424 {
425  /* NOTE: Name channels lowercase rgba so that compression rules check in OpenEXR DWA code uses
426  * loseless compression. Reportedly this naming is the only one which works good from the
427  * interoperability point of view. Using xyzw naming is not portable. */
428 
429  char cryptomatte_pass_name[MAX_NAME];
430  const short num_passes = eevee_cryptomatte_passes_per_layer(view_layer);
431  if ((view_layer->cryptomatte_flag & VIEW_LAYER_CRYPTOMATTE_OBJECT) != 0) {
432  for (short pass = 0; pass < num_passes; pass++) {
433  BLI_snprintf_rlen(cryptomatte_pass_name, MAX_NAME, "CryptoObject%02d", pass);
435  engine, scene, view_layer, cryptomatte_pass_name, 4, "rgba", SOCK_RGBA);
436  }
437  }
438  if ((view_layer->cryptomatte_flag & VIEW_LAYER_CRYPTOMATTE_MATERIAL) != 0) {
439  for (short pass = 0; pass < num_passes; pass++) {
440  BLI_snprintf_rlen(cryptomatte_pass_name, MAX_NAME, "CryptoMaterial%02d", pass);
442  engine, scene, view_layer, cryptomatte_pass_name, 4, "rgba", SOCK_RGBA);
443  }
444  }
445  if ((view_layer->cryptomatte_flag & VIEW_LAYER_CRYPTOMATTE_ASSET) != 0) {
446  for (short pass = 0; pass < num_passes; pass++) {
447  BLI_snprintf_rlen(cryptomatte_pass_name, MAX_NAME, "CryptoAsset%02d", pass);
449  engine, scene, view_layer, cryptomatte_pass_name, 4, "rgba", SOCK_RGBA);
450  }
451  }
452 }
453 
456 /* -------------------------------------------------------------------- */
460 /* Compare function for cryptomatte samples. Samples with the highest weight will be at the
461  * beginning of the list. */
462 static int eevee_cryptomatte_sample_cmp_reverse(const void *a_, const void *b_)
463 {
464  const EEVEE_CryptomatteSample *a = a_;
465  const EEVEE_CryptomatteSample *b = b_;
466  if (a->weight < b->weight) {
467  return 1;
468  }
469  if (a->weight > b->weight) {
470  return -1;
471  }
472 
473  return 0;
474 }
475 
476 /* Post process the weights. The accumulated weights buffer adds one to each weight per sample.
477  * During post processing ensure that the total of weights per sample is between 0 and 1. */
479 {
480  EEVEE_StorageList *stl = vedata->stl;
482  EEVEE_EffectsInfo *effects = stl->effects;
483  EEVEE_TextureList *txl = vedata->txl;
484  const DRWContextState *draw_ctx = DRW_context_state_get();
485  const ViewLayer *view_layer = draw_ctx->view_layer;
486  const int num_cryptomatte_layers = eevee_cryptomatte_layers_count(view_layer);
487  const int num_levels = view_layer->cryptomatte_levels;
488  const float *viewport_size = DRW_viewport_size_get();
489  const int buffer_size = viewport_size[0] * viewport_size[1];
490 
491  EEVEE_CryptomatteSample *accum_buffer = g_data->cryptomatte_accum_buffer;
492  BLI_assert(accum_buffer);
493  float *volumetric_transmittance_buffer = NULL;
494  if ((effects->enabled_effects & EFFECT_VOLUMETRIC) != 0) {
495  volumetric_transmittance_buffer = GPU_texture_read(
497  }
498  const int num_samples = effects->taa_current_sample - 1;
499 
500  int accum_pixel_index = 0;
501  int accum_pixel_stride = eevee_cryptomatte_pixel_stride(view_layer);
502 
503  for (int pixel_index = 0; pixel_index < buffer_size;
504  pixel_index++, accum_pixel_index += accum_pixel_stride) {
505  float coverage = 1.0f;
506  if (volumetric_transmittance_buffer != NULL) {
507  coverage = (volumetric_transmittance_buffer[pixel_index * 4] +
508  volumetric_transmittance_buffer[pixel_index * 4 + 1] +
509  volumetric_transmittance_buffer[pixel_index * 4 + 2]) /
510  (3.0f * num_samples);
511  }
512  for (int layer = 0; layer < num_cryptomatte_layers; layer++) {
513  const int layer_offset = eevee_cryptomatte_layer_offset(view_layer, layer);
514  /* Calculate the total weight of the sample. */
515  float total_weight = 0.0f;
516  for (int level = 0; level < num_levels; level++) {
517  EEVEE_CryptomatteSample *sample = &accum_buffer[accum_pixel_index + layer_offset + level];
518  total_weight += sample->weight;
519  }
520  BLI_assert(total_weight > 0.0f);
521 
522  float total_weight_inv = coverage / total_weight;
523  if (total_weight_inv > 0.0f) {
524  for (int level = 0; level < num_levels; level++) {
526  &accum_buffer[accum_pixel_index + layer_offset + level];
527  /* Remove background samples. These samples were used to determine the correct weight
528  * but won't be part of the final result. */
529  if (sample->hash == 0.0f) {
530  sample->weight = 0.0f;
531  }
532  sample->weight *= total_weight_inv;
533  }
534 
535  /* Sort accum buffer by coverage of each sample. */
536  qsort(&accum_buffer[accum_pixel_index + layer_offset],
537  num_levels,
538  sizeof(EEVEE_CryptomatteSample),
540  }
541  else {
542  /* This pixel doesn't have any weight, so clear it fully. */
543  for (int level = 0; level < num_levels; level++) {
545  &accum_buffer[accum_pixel_index + layer_offset + level];
546  sample->weight = 0.0f;
547  sample->hash = 0.0f;
548  }
549  }
550  }
551  }
552 
553  if (volumetric_transmittance_buffer) {
554  MEM_freeN(volumetric_transmittance_buffer);
555  }
556 }
557 
558 /* Extract cryptomatte layer from the cryptomatte_accum_buffer to render passes. */
560  RenderLayer *rl,
561  const char *viewname,
562  const char *render_pass_name_format,
563  EEVEE_CryptomatteSample *accum_buffer,
564  /* number of render passes per cryptomatte layer. */
565  const int num_cryptomatte_passes,
566  const int num_cryptomatte_levels,
567  const int accum_pixel_stride,
568  const int layer_stride,
569  const int layer_index,
570  const int rect_width,
571  const int rect_height,
572  const int rect_offset_x,
573  const int rect_offset_y,
574  const int viewport_width)
575 {
576  char cryptomatte_pass_name[MAX_NAME];
577  /* A pass can store 2 levels. Technically the last pass can have a single level if the number of
578  * levels is an odd number. This parameter counts the number of levels it has processed. */
579  int levels_done = 0;
580  for (int pass = 0; pass < num_cryptomatte_passes; pass++) {
581  /* Each pass holds 2 cryptomatte samples. */
582  const int pass_offset = pass * 2;
583  BLI_snprintf_rlen(cryptomatte_pass_name, MAX_NAME, render_pass_name_format, pass);
584  RenderPass *rp_object = RE_pass_find_by_name(rl, cryptomatte_pass_name, viewname);
585  for (int y = 0; y < rect_height; y++) {
586  for (int x = 0; x < rect_width; x++) {
587  const int accum_buffer_offset = (rect_offset_x + x +
588  (rect_offset_y + y) * viewport_width) *
589  accum_pixel_stride +
590  layer_index * layer_stride + pass_offset;
591  const int render_pass_offset = (y * rect_width + x) * 4;
592  rp_object->rect[render_pass_offset] = accum_buffer[accum_buffer_offset].hash;
593  rp_object->rect[render_pass_offset + 1] = accum_buffer[accum_buffer_offset].weight;
594  if (levels_done + 1 < num_cryptomatte_levels) {
595  rp_object->rect[render_pass_offset + 2] = accum_buffer[accum_buffer_offset + 1].hash;
596  rp_object->rect[render_pass_offset + 3] = accum_buffer[accum_buffer_offset + 1].weight;
597  }
598  else {
599  rp_object->rect[render_pass_offset + 2] = 0.0f;
600  rp_object->rect[render_pass_offset + 3] = 0.0f;
601  }
602  }
603  }
604  levels_done++;
605  }
606 }
607 
609  const char *viewname,
610  const rcti *rect,
611  EEVEE_Data *vedata,
612  EEVEE_ViewLayerData *UNUSED(sldata))
613 {
614  EEVEE_PrivateData *g_data = vedata->stl->g_data;
615  const DRWContextState *draw_ctx = DRW_context_state_get();
616  const ViewLayer *view_layer = draw_ctx->view_layer;
617  const eViewLayerCryptomatteFlags cryptomatte_layers = view_layer->cryptomatte_flag &
619 
621 
622  const int rect_width = BLI_rcti_size_x(rect);
623  const int rect_height = BLI_rcti_size_y(rect);
624  const int rect_offset_x = vedata->stl->g_data->overscan_pixels + rect->xmin;
625  const int rect_offset_y = vedata->stl->g_data->overscan_pixels + rect->ymin;
626  const float *viewport_size = DRW_viewport_size_get();
627  const int viewport_width = viewport_size[0];
628  EEVEE_CryptomatteSample *accum_buffer = g_data->cryptomatte_accum_buffer;
629  BLI_assert(accum_buffer);
630  const int num_cryptomatte_levels = view_layer->cryptomatte_levels;
631  const int num_cryptomatte_passes = eevee_cryptomatte_passes_per_layer(view_layer);
632  const int layer_stride = eevee_cryptomatte_layer_stride(view_layer);
633  const int accum_pixel_stride = eevee_cryptomatte_pixel_stride(view_layer);
634 
635  int layer_index = 0;
636  if ((cryptomatte_layers & VIEW_LAYER_CRYPTOMATTE_OBJECT) != 0) {
638  viewname,
639  "CryptoObject%02d",
640  accum_buffer,
641  num_cryptomatte_passes,
642  num_cryptomatte_levels,
643  accum_pixel_stride,
644  layer_stride,
645  layer_index,
646  rect_width,
647  rect_height,
648  rect_offset_x,
649  rect_offset_y,
650  viewport_width);
651  layer_index++;
652  }
653  if ((cryptomatte_layers & VIEW_LAYER_CRYPTOMATTE_MATERIAL) != 0) {
655  viewname,
656  "CryptoMaterial%02d",
657  accum_buffer,
658  num_cryptomatte_passes,
659  num_cryptomatte_levels,
660  accum_pixel_stride,
661  layer_stride,
662  layer_index,
663  rect_width,
664  rect_height,
665  rect_offset_x,
666  rect_offset_y,
667  viewport_width);
668  layer_index++;
669  }
670  if ((cryptomatte_layers & VIEW_LAYER_CRYPTOMATTE_ASSET) != 0) {
672  viewname,
673  "CryptoAsset%02d",
674  accum_buffer,
675  num_cryptomatte_passes,
676  num_cryptomatte_levels,
677  accum_pixel_stride,
678  layer_stride,
679  layer_index,
680  rect_width,
681  rect_height,
682  rect_offset_x,
683  rect_offset_y,
684  viewport_width);
685  layer_index++;
686  }
687 }
688 
690 {
691  EEVEE_PrivateData *g_data = vedata->stl->g_data;
692  const DRWContextState *draw_ctx = DRW_context_state_get();
693  const ViewLayer *view_layer = draw_ctx->view_layer;
694  BLI_assert(g_data->cryptomatte_session);
695 
696  BKE_cryptomatte_store_metadata(g_data->cryptomatte_session, render_result, view_layer);
697 }
698 
702 {
703  EEVEE_PrivateData *g_data = vedata->stl->g_data;
704  MEM_SAFE_FREE(g_data->cryptomatte_accum_buffer);
705  MEM_SAFE_FREE(g_data->cryptomatte_download_buffer);
706  if (g_data->cryptomatte_session) {
707  BKE_cryptomatte_free(g_data->cryptomatte_session);
708  g_data->cryptomatte_session = NULL;
709  }
710 }
void BKE_cryptomatte_add_layer(struct CryptomatteSession *session, const char *layer_name)
Definition: cryptomatte.cc:145
uint32_t BKE_cryptomatte_asset_hash(struct CryptomatteSession *session, const char *layer_name, const struct Object *object)
void BKE_cryptomatte_store_metadata(const struct CryptomatteSession *session, struct RenderResult *render_result, const ViewLayer *view_layer)
Definition: cryptomatte.cc:308
float BKE_cryptomatte_hash_to_float(uint32_t cryptomatte_hash)
Definition: cryptomatte.cc:194
uint32_t BKE_cryptomatte_object_hash(struct CryptomatteSession *session, const char *layer_name, const struct Object *object)
uint32_t BKE_cryptomatte_material_hash(struct CryptomatteSession *session, const char *layer_name, const struct Material *material)
struct CryptomatteSession * BKE_cryptomatte_init(void)
Definition: cryptomatte.cc:126
void BKE_cryptomatte_free(struct CryptomatteSession *session)
Definition: cryptomatte.cc:150
struct Material * BKE_object_material_get_eval(struct Object *ob, short act)
Definition: material.c:707
#define BLI_array_alloca(arr, realsize)
Definition: BLI_alloca.h:22
#define BLI_assert(a)
Definition: BLI_assert.h:46
#define BLI_INLINE
#define LISTBASE_FOREACH(type, var, list)
Definition: BLI_listbase.h:336
MINLINE int count_bits_i(unsigned int n)
BLI_INLINE int BLI_rcti_size_y(const struct rcti *rct)
Definition: BLI_rect.h:190
BLI_INLINE int BLI_rcti_size_x(const struct rcti *rct)
Definition: BLI_rect.h:186
size_t BLI_snprintf_rlen(char *__restrict dst, size_t maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
#define UNUSED(x)
int rect_width(int rect[2][2])
Definition: Basic.c:42
int rect_height(int rect[2][2])
Definition: Basic.c:46
#define CURVES_MATERIAL_NR
#define MAX_NAME
Definition: DNA_defs.h:48
eViewLayerCryptomatteFlags
@ VIEW_LAYER_CRYPTOMATTE_MATERIAL
@ VIEW_LAYER_CRYPTOMATTE_ASSET
@ VIEW_LAYER_CRYPTOMATTE_ACCURATE
@ VIEW_LAYER_CRYPTOMATTE_OBJECT
#define VIEW_LAYER_CRYPTOMATTE_ALL
@ EEVEE_RENDER_PASS_VOLUME_LIGHT
@ EEVEE_RENDER_PASS_CRYPTOMATTE
@ eModifierType_ParticleSystem
@ SOCK_RGBA
@ OB_MESH
@ OB_CURVES
#define PART_DRAW_PATH
#define PART_DRAW_REND
@ DRW_STATE_DEPTH_EQUAL
Definition: DRW_render.h:312
@ DRW_STATE_WRITE_COLOR
Definition: DRW_render.h:303
#define DRW_PASS_CREATE(pass, state)
Definition: DRW_render.h:690
#define DRW_shgroup_uniform_block(shgroup, name, ubo)
Definition: DRW_render.h:651
#define DRW_shgroup_call(shgroup, geom, ob)
Definition: DRW_render.h:414
GPUBatch
Definition: GPU_batch.h:78
struct GPUFrameBuffer GPUFrameBuffer
void GPU_framebuffer_bind(GPUFrameBuffer *fb)
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint y
void * GPU_texture_read(GPUTexture *tex, eGPUDataFormat data_format, int miplvl)
Definition: gpu_texture.cc:432
@ GPU_DATA_FLOAT
Definition: GPU_texture.h:171
eGPUTextureFormat
Definition: GPU_texture.h:83
@ GPU_RGBA32F
Definition: GPU_texture.h:90
@ GPU_RG32F
Definition: GPU_texture.h:100
#define MEM_SAFE_FREE(v)
Scene scene
Material material
GPUBatch ** DRW_cache_object_surface_material_get(struct Object *ob, struct GPUMaterial **gpumat_array, uint gpumat_array_len)
Definition: draw_cache.c:971
int DRW_cache_object_material_count_get(struct Object *ob)
Definition: draw_cache.c:936
GPUBatch * DRW_cache_object_surface_get(Object *ob)
Definition: draw_cache.c:887
struct DRWShadingGroup * DRW_shgroup_curves_create_sub(struct Object *object, struct DRWShadingGroup *shgrp, struct GPUMaterial *gpu_material)
Definition: draw_curves.cc:303
struct DRWShadingGroup * DRW_shgroup_hair_create_sub(struct Object *object, struct ParticleSystem *psys, struct ModifierData *md, struct DRWShadingGroup *shgrp, struct GPUMaterial *gpu_material)
Definition: draw_hair.cc:235
bool DRW_object_is_visible_psys_in_active_context(const Object *object, const ParticleSystem *psys)
Definition: draw_manager.c:234
const DRWContextState * DRW_context_state_get(void)
const float * DRW_viewport_size_get(void)
Definition: draw_manager.c:288
bool DRW_state_is_scene_render(void)
DefaultTextureList * DRW_viewport_texture_list_get(void)
Definition: draw_manager.c:638
DRWShadingGroup * DRW_shgroup_create(struct GPUShader *shader, DRWPass *pass)
void DRW_shgroup_uniform_vec4_copy(DRWShadingGroup *shgroup, const char *name, const float *value)
void DRW_draw_pass(DRWPass *pass)
void DRW_texture_ensure_fullscreen_2d(GPUTexture **tex, eGPUTextureFormat format, DRWTextureFlag flags)
static struct @318 g_data
void EEVEE_cryptomatte_particle_hair_cache_populate(EEVEE_Data *vedata, EEVEE_ViewLayerData *sldata, Object *ob)
void EEVEE_cryptomatte_object_curves_cache_populate(EEVEE_Data *vedata, EEVEE_ViewLayerData *sldata, Object *ob)
void EEVEE_cryptomatte_output_init(EEVEE_ViewLayerData *UNUSED(sldata), EEVEE_Data *vedata, int UNUSED(tot_samples))
BLI_INLINE eViewLayerCryptomatteFlags eevee_cryptomatte_active_layers(const ViewLayer *view_layer)
static void eevee_cryptomatte_download_buffer(EEVEE_Data *vedata, GPUFrameBuffer *framebuffer)
void EEVEE_cryptomatte_store_metadata(EEVEE_Data *vedata, RenderResult *render_result)
void EEVEE_cryptomatte_cache_populate(EEVEE_Data *vedata, EEVEE_ViewLayerData *sldata, Object *ob)
BLI_INLINE int eevee_cryptomatte_layer_offset(const ViewLayer *view_layer, const int layer)
BLI_INLINE int eevee_cryptomatte_layers_count(const ViewLayer *view_layer)
static void eevee_cryptomatte_extract_render_passes(RenderLayer *rl, const char *viewname, const char *render_pass_name_format, EEVEE_CryptomatteSample *accum_buffer, const int num_cryptomatte_passes, const int num_cryptomatte_levels, const int accum_pixel_stride, const int layer_stride, const int layer_index, const int rect_width, const int rect_height, const int rect_offset_x, const int rect_offset_y, const int viewport_width)
void EEVEE_cryptomatte_free(EEVEE_Data *vedata)
BLI_INLINE int eevee_cryptomatte_layer_stride(const ViewLayer *view_layer)
static void eevee_cryptomatte_curves_cache_populate(EEVEE_Data *vedata, EEVEE_ViewLayerData *sldata, Object *ob, ParticleSystem *psys, ModifierData *md, Material *material)
void EEVEE_cryptomatte_cache_init(EEVEE_ViewLayerData *UNUSED(sldata), EEVEE_Data *vedata)
static int eevee_cryptomatte_sample_cmp_reverse(const void *a_, const void *b_)
void EEVEE_cryptomatte_output_accumulate(EEVEE_ViewLayerData *UNUSED(sldata), EEVEE_Data *vedata)
static DRWShadingGroup * eevee_cryptomatte_shading_group_create(EEVEE_Data *vedata, EEVEE_ViewLayerData *sldata, Object *ob, Material *material, bool is_hair)
BLI_INLINE int eevee_cryptomatte_pixel_stride(const ViewLayer *view_layer)
BLI_INLINE int eevee_cryptomatte_passes_per_layer(const ViewLayer *view_layer)
void EEVEE_cryptomatte_render_result(RenderLayer *rl, const char *viewname, const rcti *rect, EEVEE_Data *vedata, EEVEE_ViewLayerData *UNUSED(sldata))
void EEVEE_cryptomatte_update_passes(RenderEngine *engine, Scene *scene, ViewLayer *view_layer)
void EEVEE_cryptomatte_renderpasses_init(EEVEE_Data *vedata)
static void eevee_cryptomatte_postprocess_weights(EEVEE_Data *vedata)
depth_tx normal_tx diffuse_light_tx specular_light_tx volume_light_tx environment_tx ambient_occlusion_tx aov_value_tx GPU_R32F
struct GPUShader * EEVEE_shaders_cryptomatte_sh_get(bool is_hair)
@ EFFECT_VOLUMETRIC
void RE_engine_register_pass(struct RenderEngine *engine, struct Scene *scene, struct ViewLayer *view_layer, const char *name, int channels, const char *chanid, eNodeSocketDatatype type)
Definition: engine.c:1171
void GPU_framebuffer_read_color(GPUFrameBuffer *gpu_fb, int x, int y, int w, int h, int channels, int slot, eGPUDataFormat format, void *data)
ccl_gpu_kernel_postfix ccl_global float int int int int ccl_global const float int int int int int int int int int int int int num_samples
format
Definition: logImageCore.h:38
void *(* MEM_malloc_arrayN)(size_t len, size_t size, const char *str)
Definition: mallocn.c:34
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
void *(* MEM_calloc_arrayN)(size_t len, size_t size, const char *str)
Definition: mallocn.c:32
static unsigned a[3]
Definition: RandGen.cpp:78
static const pxr::TfToken b("b", pxr::TfToken::Immortal)
RenderPass * RE_pass_find_by_name(RenderLayer *rl, const char *name, const char *viewname)
Definition: pipeline.c:2591
unsigned int uint32_t
Definition: stdint.h:80
struct ViewLayer * view_layer
Definition: DRW_render.h:980
struct Object * object_edit
Definition: DRW_render.h:1003
EEVEE_TextureList * txl
EEVEE_StorageList * stl
EEVEE_PassList * psl
EEVEE_FramebufferList * fbl
EEVEE_EffectsFlag enabled_effects
struct GPUFrameBuffer * main_fb
struct GPUFrameBuffer * cryptomatte_fb
struct DRWPass * cryptomatte_ps
eViewLayerEEVEEPassType render_passes
struct EEVEE_PrivateData * g_data
struct EEVEE_EffectsInfo * effects
struct GPUTexture * volume_transmittance_accum
struct GPUTexture * cryptomatte
struct GPUUniformBuf * shadow_ubo
ListBase modifiers
ParticleSettings * part
float * rect
Definition: RE_pipeline.h:67
short cryptomatte_flag
short cryptomatte_levels
int ymin
Definition: DNA_vec_types.h:64
int xmin
Definition: DNA_vec_types.h:63