Add Chromium-only Blender WebEngine parity work

blender-5.2.0/source/blender/animrig/intern/keyingsets.cc

@@ -0,0 +1,469 @@
+/* SPDX-FileCopyrightText: 2024 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+/** \file
+ * \ingroup animrig
+ */
+
+#include "ANIM_keyframing.hh"
+#include "ANIM_keyingsets.hh"
+
+#include "BKE_animsys.h"
+#include "BKE_context.hh"
+#include "BKE_main.hh"
+#include "BKE_report.hh"
+
+#include "BLI_listbase.h"
+#include "BLI_string.h"
+
+#include "DEG_depsgraph.hh"
+
+#include "DNA_anim_types.h"
+#include "DNA_scene_types.h"
+
+#include "RNA_access.hh"
+
+#include "WM_api.hh"
+
+namespace blender {
+
+/* Keying Set Type Info declarations. */
+static ListBaseT<KeyingSetInfo> keyingset_type_infos = {nullptr, nullptr};
+ListBaseT<KeyingSet> builtin_keyingsets = {nullptr, nullptr};
+
+namespace animrig {
+
+void keyingset_info_register(KeyingSetInfo *keyingset_info)
+{
+  /* Create a new KeyingSet
+   * - inherit name and keyframing settings from the typeinfo
+   */
+  KeyingSet *keyingset = BKE_keyingset_add(&builtin_keyingsets,
+                                           keyingset_info->idname,
+                                           keyingset_info->name,
+                                           eKS_Settings{},
+                                           keyingset_info->keyingflag);
+
+  /* Link this KeyingSet with its typeinfo. */
+  memcpy(&keyingset->typeinfo, keyingset_info->idname, sizeof(keyingset->typeinfo));
+
+  /* Copy description. */
+  STRNCPY(keyingset->description, keyingset_info->description);
+
+  /* Add type-info to the list. */
+  BLI_addtail(&keyingset_type_infos, keyingset_info);
+}
+
+void keyingset_info_unregister(Main *bmain, KeyingSetInfo *keyingset_info)
+{
+  /* Find relevant builtin KeyingSets which use this, and remove them. */
+  /* TODO: this isn't done now, since unregister is really only used at the moment when we
+   * reload the scripts, which kind of defeats the purpose of "builtin"? */
+  for (KeyingSet &keyingset : builtin_keyingsets.items_mutable()) {
+    /* Remove if matching typeinfo name. */
+    if (!STREQ(keyingset.typeinfo, keyingset_info->idname)) {
+      continue;
+    }
+    Scene *scene;
+    BKE_keyingset_free_paths(&keyingset);
+    BLI_remlink(&builtin_keyingsets, &keyingset);
+
+    for (scene = static_cast<Scene *>(bmain->scenes.first); scene;
+         scene = static_cast<Scene *>(scene->id.next))
+    {
+      BLI_remlink_safe(&scene->keyingsets, &keyingset);
+    }
+
+    MEM_delete(&keyingset);
+  }
+
+  BLI_freelinkN(&keyingset_type_infos, keyingset_info);
+}
+
+void keyingset_infos_exit()
+{
+  /* Free type infos. */
+  for (KeyingSetInfo &keyingset_info : keyingset_type_infos.items_mutable()) {
+    /* Free extra RNA data, and remove from list. */
+    if (keyingset_info.rna_ext.free) {
+      keyingset_info.rna_ext.free(keyingset_info.rna_ext.data);
+    }
+    BLI_freelinkN(&keyingset_type_infos, &keyingset_info);
+  }
+
+  BKE_keyingsets_free(&builtin_keyingsets);
+}
+
+bool keyingset_find_id(KeyingSet *keyingset, ID *id)
+{
+  if (ELEM(nullptr, keyingset, id)) {
+    return false;
+  }
+
+  return BLI_findptr(&keyingset->paths, id, offsetof(KS_Path, id)) != nullptr;
+}
+
+KeyingSetInfo *keyingset_info_find_name(const char name[])
+{
+  if ((name == nullptr) || (name[0] == 0)) {
+    return nullptr;
+  }
+
+  /* Search by comparing names. */
+  return static_cast<KeyingSetInfo *>(
+      BLI_findstring(&keyingset_type_infos, name, offsetof(KeyingSetInfo, idname)));
+}
+
+KeyingSet *builtin_keyingset_get_named(const char name[])
+{
+  if (name[0] == 0) {
+    return nullptr;
+  }
+
+  /* Loop over KeyingSets checking names. */
+  for (KeyingSet &keyingset : builtin_keyingsets) {
+    if (STREQ(name, keyingset.idname)) {
+      return &keyingset;
+    }
+  }
+
+/* Complain about missing keying sets on debug builds. */
+#ifndef NDEBUG
+  printf("%s: '%s' not found\n", __func__, name);
+#endif
+
+  return nullptr;
+}
+
+KeyingSet *get_keyingset_for_autokeying(const Scene *scene, const char *transformKSName)
+{
+  /* Get KeyingSet to use
+   * - use the active KeyingSet if defined (and user wants to use it for all autokeying),
+   *   or otherwise key transforms only
+   */
+  if (is_keying_flag(scene, AUTOKEY_FLAG_ONLYKEYINGSET) && (scene->active_keyingset)) {
+    return scene_get_active_keyingset(scene);
+  }
+
+  if (is_keying_flag(scene, AUTOKEY_FLAG_INSERTAVAILABLE)) {
+    return builtin_keyingset_get_named(ANIM_KS_AVAILABLE_ID);
+  }
+
+  return builtin_keyingset_get_named(transformKSName);
+}
+
+KeyingSet *scene_get_active_keyingset(const Scene *scene)
+{
+  /* If no scene, we've got no hope of finding the Keying Set. */
+  if (scene == nullptr) {
+    return nullptr;
+  }
+
+  /* Currently, there are several possibilities here:
+   * -   0: no active keying set
+   * - > 0: one of the user-defined Keying Sets, but indices start from 0 (hence the -1)
+   * - < 0: a builtin keying set
+   */
+  if (scene->active_keyingset > 0) {
+    return static_cast<KeyingSet *>(BLI_findlink(&scene->keyingsets, scene->active_keyingset - 1));
+  }
+  return static_cast<KeyingSet *>(
+      BLI_findlink(&builtin_keyingsets, (-scene->active_keyingset) - 1));
+}
+
+void relative_keyingset_add_source(Vector<PointerRNA> &sources,
+                                   ID *id,
+                                   StructRNA *srna,
+                                   void *data)
+{
+  if (ELEM(nullptr, srna, data, id)) {
+    return;
+  }
+  sources.append(RNA_pointer_create_discrete(id, srna, data));
+}
+
+void relative_keyingset_add_source(Vector<PointerRNA> &sources, ID *id)
+{
+  if (id == nullptr) {
+    return;
+  }
+  sources.append(RNA_id_pointer_create(id));
+}
+
+/* Special 'Overrides' Iterator for Relative KeyingSets ------ */
+
+/* Iterator used for overriding the behavior of iterators defined for
+ * relative Keying Sets, with the main usage of this being operators
+ * requiring Auto Keyframing. Internal Use Only!
+ */
+static void RKS_ITER_overrides_list(KeyingSetInfo *keyingset_info,
+                                    bContext *C,
+                                    KeyingSet *keyingset,
+                                    Vector<PointerRNA> &sources)
+{
+  for (PointerRNA ptr : sources) {
+    /* Run generate callback on this data. */
+    keyingset_info->generate(keyingset_info, C, keyingset, &ptr);
+  }
+}
+
+ModifyKeyReturn validate_keyingset(bContext *C, Vector<PointerRNA> *sources, KeyingSet *keyingset)
+{
+  if (keyingset == nullptr) {
+    return ModifyKeyReturn::SUCCESS;
+  }
+
+  /* If relative Keying Sets, poll and build up the paths. */
+  if (keyingset->flag & KEYINGSET_ABSOLUTE) {
+    return ModifyKeyReturn::SUCCESS;
+  }
+
+  KeyingSetInfo *keyingset_info = keyingset_info_find_name(keyingset->typeinfo);
+
+  /* Clear all existing paths
+   * NOTE: BKE_keyingset_free_paths() frees all of the paths for the KeyingSet, but not the set
+   * itself.
+   */
+  BKE_keyingset_free_paths(keyingset);
+
+  /* Get the associated 'type info' for this KeyingSet. */
+  if (keyingset_info == nullptr) {
+    return ModifyKeyReturn::MISSING_TYPEINFO;
+  }
+  /* TODO: check for missing callbacks! */
+
+  /* Check if it can be used in the current context. */
+  if (!keyingset_info->poll(keyingset_info, C)) {
+    /* Poll callback tells us that KeyingSet is useless in current context. */
+    /* FIXME: the poll callback needs to give us more info why. */
+    return ModifyKeyReturn::INVALID_CONTEXT;
+  }
+
+  /* If a list of data sources are provided, run a special iterator over them,
+   * otherwise, just continue per normal.
+   */
+  if (sources != nullptr) {
+    RKS_ITER_overrides_list(keyingset_info, C, keyingset, *sources);
+  }
+  else {
+    keyingset_info->iter(keyingset_info, C, keyingset);
+  }
+
+  /* If we don't have any paths now, then this still qualifies as invalid context. */
+  /* FIXME: we need some error conditions (to be retrieved from the iterator why this failed!)
+   */
+  if (keyingset->paths.is_empty()) {
+    return ModifyKeyReturn::INVALID_CONTEXT;
+  }
+
+  return ModifyKeyReturn::SUCCESS;
+}
+
+/* Determine which keying flags apply based on the override flags. */
+static eInsertKeyFlags keyingset_apply_keying_flags(const eInsertKeyFlags base_flags,
+                                                    const eInsertKeyFlags overrides,
+                                                    const eInsertKeyFlags own_flags)
+{
+  /* Pass through all flags by default (i.e. even not explicitly listed ones). */
+  eInsertKeyFlags result = base_flags;
+
+/* The logic for whether a keying flag applies is as follows:
+ * - If the flag in question is set in "overrides", that means that the
+ *   status of that flag in "own_flags" is used
+ * - If however the flag isn't set, then its value in "base_flags" is used
+ *   instead (i.e. no override)
+ */
+#define APPLY_KEYINGFLAG_OVERRIDE(kflag) \
+  if (overrides & kflag) { \
+    result &= ~kflag; \
+    result |= (own_flags & kflag); \
+  }
+
+  /* Apply the flags one by one...
+   * (See rna_def_common_keying_flags() for the supported flags)
+   */
+  APPLY_KEYINGFLAG_OVERRIDE(INSERTKEY_NEEDED)
+  APPLY_KEYINGFLAG_OVERRIDE(INSERTKEY_MATRIX)
+
+#undef APPLY_KEYINGFLAG_OVERRIDE
+
+  return result;
+}
+
+static int insert_key_to_keying_set_path(bContext *C,
+                                         KS_Path *keyingset_path,
+                                         KeyingSet *keyingset,
+                                         const eInsertKeyFlags insert_key_flags,
+                                         const ModifyKeyMode mode,
+                                         const float frame)
+{
+  if (!keyingset_path->rna_path) {
+    /* In case the path is incomplete/not filled in by the user. */
+    return 0;
+  }
+  /* Since keying settings can be defined on the paths too,
+   * apply the settings for this path first. */
+  const eInsertKeyFlags path_insert_key_flags = keyingset_apply_keying_flags(
+      insert_key_flags,
+      eInsertKeyFlags(keyingset_path->keyingoverride),
+      eInsertKeyFlags(keyingset_path->keyingflag));
+
+  const char *groupname = nullptr;
+  /* Get pointer to name of group to add channels to. */
+  if (keyingset_path->groupmode == KSP_GROUP_NONE) {
+    groupname = nullptr;
+  }
+  else if (keyingset_path->groupmode == KSP_GROUP_KSNAME) {
+    groupname = keyingset->name;
+  }
+  else {
+    groupname = keyingset_path->group;
+  }
+
+  /* Init - array_length should be greater than array_index so that
+   * normal non-array entries get keyframed correctly.
+   */
+  int array_index = keyingset_path->array_index;
+  int array_length = array_index;
+
+  /* Get length of array if whole array option is enabled. */
+  if (keyingset_path->flag & KSP_FLAG_WHOLE_ARRAY) {
+    PointerRNA ptr;
+    PropertyRNA *prop;
+
+    PointerRNA id_ptr = RNA_id_pointer_create(keyingset_path->id);
+    if (RNA_path_resolve_property(&id_ptr, keyingset_path->rna_path, &ptr, &prop)) {
+      array_length = RNA_property_array_length(&ptr, prop);
+      /* Start from start of array, instead of the previously specified index - #48020 */
+      array_index = 0;
+    }
+  }
+
+  /* We should do at least one step. */
+  if (array_length == array_index) {
+    array_length++;
+  }
+
+  Main *bmain = CTX_data_main(C);
+  ReportList *reports = CTX_wm_reports(C);
+  Scene *scene = CTX_data_scene(C);
+  const eBezTriple_KeyframeType keytype = eBezTriple_KeyframeType(
+      scene->toolsettings->keyframe_type);
+  /* For each possible index, perform operation
+   * - Assume that array-length is greater than index. */
+  Depsgraph *depsgraph = CTX_data_depsgraph_pointer(C);
+  const AnimationEvalContext anim_eval_context = BKE_animsys_eval_context_construct(depsgraph,
+                                                                                    frame);
+  int keyed_channels = 0;
+
+  CombinedKeyingResult combined_result;
+  for (; array_index < array_length; array_index++) {
+    if (mode == ModifyKeyMode::INSERT) {
+      const std::optional<StringRefNull> group = groupname ? std::optional(groupname) :
+                                                             std::nullopt;
+      const std::optional<int> index = array_index >= 0 ? std::optional(array_index) :
+                                                          std::nullopt;
+      PointerRNA id_rna_pointer = RNA_id_pointer_create(keyingset_path->id);
+      CombinedKeyingResult result = insert_keyframes(bmain,
+                                                     &id_rna_pointer,
+                                                     group,
+                                                     {{keyingset_path->rna_path, {}, index}},
+                                                     std::nullopt,
+                                                     anim_eval_context,
+                                                     keytype,
+                                                     path_insert_key_flags);
+      keyed_channels += result.get_count(SingleKeyingResult::SUCCESS);
+      combined_result.merge(result);
+    }
+    else if (mode == ModifyKeyMode::DELETE_KEY) {
+      RNAPath rna_path = {keyingset_path->rna_path, std::nullopt, array_index};
+      if (array_index < 0) {
+        rna_path.index = std::nullopt;
+      }
+      keyed_channels += delete_keyframe(bmain, reports, keyingset_path->id, rna_path, frame);
+    }
+  }
+
+  if (combined_result.get_count(SingleKeyingResult::SUCCESS) == 0) {
+    combined_result.generate_reports(reports);
+  }
+
+  switch (GS(keyingset_path->id->name)) {
+    case ID_OB: /* Object (or Object-Related) Keyframes */
+    {
+      Object *ob = reinterpret_cast<Object *>(keyingset_path->id);
+
+      /* XXX: only object transforms? */
+      DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
+      break;
+    }
+    default:
+      DEG_id_tag_update(keyingset_path->id, ID_RECALC_ANIMATION_NO_FLUSH);
+      break;
+  }
+
+  WM_main_add_notifier(NC_ANIMATION | ND_KEYFRAME | NA_ADDED, nullptr);
+
+  return keyed_channels;
+}
+
+int apply_keyingset(bContext *C,
+                    Vector<PointerRNA> *sources,
+                    KeyingSet *keyingset,
+                    const ModifyKeyMode mode,
+                    const float cfra)
+{
+  if (keyingset == nullptr) {
+    return 0;
+  }
+
+  Scene *scene = CTX_data_scene(C);
+  const eInsertKeyFlags base_kflags = get_keyframing_flags(scene);
+  eInsertKeyFlags kflag = INSERTKEY_NOFLAGS;
+  if (mode == ModifyKeyMode::INSERT) {
+    /* Use context settings as base. */
+    kflag = keyingset_apply_keying_flags(base_kflags,
+                                         eInsertKeyFlags(keyingset->keyingoverride),
+                                         eInsertKeyFlags(keyingset->keyingflag));
+  }
+  else if (mode == ModifyKeyMode::DELETE_KEY) {
+    kflag = INSERTKEY_NOFLAGS;
+  }
+
+  /* If relative Keying Sets, poll and build up the paths. */
+  {
+    const ModifyKeyReturn error = validate_keyingset(C, sources, keyingset);
+    if (error != ModifyKeyReturn::SUCCESS) {
+      BLI_assert(int(error) < 0);
+      return int(error);
+    }
+  }
+
+  ReportList *reports = CTX_wm_reports(C);
+  int keyed_channels = 0;
+
+  /* Apply the paths as specified in the KeyingSet now. */
+  for (KS_Path &keyingset_path : keyingset->paths) {
+    /* Skip path if no ID pointer is specified. */
+    if (keyingset_path.id == nullptr) {
+      BKE_reportf(reports,
+                  RPT_WARNING,
+                  "Skipping path in keying set, as it has no ID (KS = '%s', path = '%s[%d]')",
+                  keyingset->name,
+                  keyingset_path.rna_path,
+                  keyingset_path.array_index);
+      continue;
+    }
+
+    keyed_channels += insert_key_to_keying_set_path(
+        C, &keyingset_path, keyingset, kflag, mode, cfra);
+  }
+
+  /* Return the number of channels successfully affected. */
+  BLI_assert(keyed_channels >= 0);
+  return keyed_channels;
+}
+
+}  // namespace animrig
+}  // namespace blender