Realtime Compositor: Implement static cache manager

This patch introduces the concept of a Cached Resource that can be
cached across compositor evaluations as well as used by multiple
operations in the same evaluation. Additionally, this patch implements a
new structure for the realtime compositor, the Static Cache Manager,
that manages all the cached resources and deletes them when they are no
longer needed.

This improves responsiveness while adjusting compositor node trees and
also conserves memory usage.

Differential Revision: https://developer.blender.org/D16357

Reviewed By: Clement Foucault

1 files changed, 159 insertions, 0 deletions

diff --git a/source/blender/compositor/realtime_compositor/cached_resources/intern/morphological_distance_feather_weights.cc b/source/blender/compositor/realtime_compositor/cached_resources/intern/morphological_distance_feather_weights.cc
new file mode 100644
index 00000000000..eac88b907b8
--- /dev/null
+++ b/source/blender/compositor/realtime_compositor/cached_resources/intern/morphological_distance_feather_weights.cc
@@ -0,0 +1,159 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#include <cmath>
+#include <cstdint>
+
+#include "BLI_array.hh"
+#include "BLI_hash.hh"
+#include "BLI_index_range.hh"
+
+#include "RE_pipeline.h"
+
+#include "DNA_scene_types.h"
+
+#include "GPU_shader.h"
+#include "GPU_texture.h"
+
+#include "COM_morphological_distance_feather_weights.hh"
+
+namespace blender::realtime_compositor {
+
+/* --------------------------------------------------------------------
+ * Morphological Distance Feather Weights Key.
+ */
+
+MorphologicalDistanceFeatherWeightsKey::MorphologicalDistanceFeatherWeightsKey(int type,
+                                                                               float radius)
+    : type(type), radius(radius)
+{
+}
+
+uint64_t MorphologicalDistanceFeatherWeightsKey::hash() const
+{
+  return get_default_hash_2(type, radius);
+}
+
+bool operator==(const MorphologicalDistanceFeatherWeightsKey &a,
+                const MorphologicalDistanceFeatherWeightsKey &b)
+{
+  return a.type == b.type && a.radius == b.radius;
+}
+
+/* --------------------------------------------------------------------
+ * Morphological Distance Feather Weights.
+ */
+
+MorphologicalDistanceFeatherWeights::MorphologicalDistanceFeatherWeights(int type, int radius)
+{
+  compute_weights(radius);
+  compute_distance_falloffs(type, radius);
+}
+
+MorphologicalDistanceFeatherWeights::~MorphologicalDistanceFeatherWeights()
+{
+  GPU_texture_free(weights_texture_);
+  GPU_texture_free(distance_falloffs_texture_);
+}
+
+void MorphologicalDistanceFeatherWeights::compute_weights(int radius)
+{
+  /* The size of filter is double the radius plus 1, but since the filter is symmetric, we only
+   * compute half of it and no doubling happens. We add 1 to make sure the filter size is always
+   * odd and there is a center weight. */
+  const int size = radius + 1;
+  Array<float> weights(size);
+
+  float sum = 0.0f;
+
+  /* First, compute the center weight. */
+  const float center_weight = RE_filter_value(R_FILTER_GAUSS, 0.0f);
+  weights[0] = center_weight;
+  sum += center_weight;
+
+  /* Second, compute the other weights in the positive direction, making sure to add double the
+   * weight to the sum of weights because the filter is symmetric and we only loop over half of
+   * it. Skip the center weight already computed by dropping the front index. */
+  const float scale = radius > 0.0f ? 1.0f / radius : 0.0f;
+  for (const int i : weights.index_range().drop_front(1)) {
+    const float weight = RE_filter_value(R_FILTER_GAUSS, i * scale);
+    weights[i] = weight;
+    sum += weight * 2.0f;
+  }
+
+  /* Finally, normalize the weights. */
+  for (const int i : weights.index_range()) {
+    weights[i] /= sum;
+  }
+
+  weights_texture_ = GPU_texture_create_1d("Weights", size, 1, GPU_R16F, weights.data());
+}
+
+/* Computes a falloff that is equal to 1 at an input of zero and decrease to zero at an input of 1,
+ * with the rate of decrease depending on the falloff type. */
+static float compute_distance_falloff(int type, float x)
+{
+  x = 1.0f - x;
+
+  switch (type) {
+    case PROP_SMOOTH:
+      return 3.0f * x * x - 2.0f * x * x * x;
+    case PROP_SPHERE:
+      return std::sqrt(2.0f * x - x * x);
+    case PROP_ROOT:
+      return std::sqrt(x);
+    case PROP_SHARP:
+      return x * x;
+    case PROP_INVSQUARE:
+      return x * (2.0f - x);
+    case PROP_LIN:
+      return x;
+    default:
+      BLI_assert_unreachable();
+      return x;
+  }
+}
+
+void MorphologicalDistanceFeatherWeights::compute_distance_falloffs(int type, int radius)
+{
+  /* The size of the distance falloffs is double the radius plus 1, but since the falloffs are
+   * symmetric, we only compute half of them and no doubling happens. We add 1 to make sure the
+   * falloffs size is always odd and there is a center falloff. */
+  const int size = radius + 1;
+  Array<float> falloffs(size);
+
+  /* Compute the distance falloffs in the positive direction only, because the falloffs are
+   * symmetric. */
+  const float scale = radius > 0.0f ? 1.0f / radius : 0.0f;
+  for (const int i : falloffs.index_range()) {
+    falloffs[i] = compute_distance_falloff(type, i * scale);
+  }
+
+  distance_falloffs_texture_ = GPU_texture_create_1d(
+      "Distance Factors", size, 1, GPU_R16F, falloffs.data());
+}
+
+void MorphologicalDistanceFeatherWeights::bind_weights_as_texture(GPUShader *shader,
+                                                                  const char *texture_name) const
+{
+  const int texture_image_unit = GPU_shader_get_texture_binding(shader, texture_name);
+  GPU_texture_bind(weights_texture_, texture_image_unit);
+}
+
+void MorphologicalDistanceFeatherWeights::unbind_weights_as_texture() const
+{
+  GPU_texture_unbind(weights_texture_);
+}
+
+void MorphologicalDistanceFeatherWeights::bind_distance_falloffs_as_texture(
+    GPUShader *shader, const char *texture_name) const
+{
+  const int texture_image_unit = GPU_shader_get_texture_binding(shader, texture_name);
+  GPU_texture_bind(distance_falloffs_texture_, texture_image_unit);
+}
+
+void MorphologicalDistanceFeatherWeights::unbind_distance_falloffs_as_texture() const
+{
+  GPU_texture_unbind(distance_falloffs_texture_);
+}
+
+}  // namespace blender::realtime_compositor