rna_rna.cc

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#include <cstdlib>
 
#include <CLG_log.h>
 
#include "DNA_ID.h"
 
#include "BLI_utildefines.h"
 
#include "RNA_access.hh"
#include "RNA_define.hh"
#include "RNA_enum_types.hh"
 
#include "rna_internal.hh"
 
/* -------------------------------------------------------------------- */
/* Reuse for dynamic types. */
 
const EnumPropertyItem rna_enum_dummy_NULL_items[] = {
    {0, nullptr, 0, nullptr, nullptr},
};
 
/* Reuse for dynamic types with default value. */
 
const EnumPropertyItem rna_enum_dummy_DEFAULT_items[] = {
    {0, "DEFAULT", 0, "Default", ""},
    {0, nullptr, 0, nullptr, nullptr},
};
 
/* -------------------------------------------------------------------- */
const EnumPropertyItem rna_enum_property_type_items[] = {
    {PROP_BOOLEAN, "BOOLEAN", 0, "Boolean", ""},
    {PROP_INT, "INT", 0, "Integer", ""},
    {PROP_FLOAT, "FLOAT", 0, "Float", ""},
    {PROP_STRING, "STRING", 0, "String", ""},
    {PROP_ENUM, "ENUM", 0, "Enumeration", ""},
    {PROP_POINTER, "POINTER", 0, "Pointer", ""},
    {PROP_COLLECTION, "COLLECTION", 0, "Collection", ""},
    {0, nullptr, 0, nullptr, nullptr},
};
 
/* Wraps multiple enums onto a single line in a way that is difficult to read.
 * NOTE: these enums are split up based on their use in `bpy.props` Python module. */
 
/* clang-format off */
#define RNA_ENUM_PROPERTY_SUBTYPE_STRING_ITEMS \
  {PROP_FILEPATH, "FILE_PATH", 0, "File Path", ""}, \
  {PROP_DIRPATH, "DIR_PATH", 0, "Directory Path", ""}, \
  {PROP_FILENAME, "FILE_NAME", 0, "File Name", ""}, \
  {PROP_BYTESTRING, "BYTE_STRING", 0, "Byte String", ""}, \
  {PROP_PASSWORD, "PASSWORD", 0, "Password", "A string that is displayed hidden ('********')"}
 
#define RNA_ENUM_PROPERTY_SUBTYPE_NUMBER_ITEMS \
  {PROP_PIXEL, "PIXEL", 0, "Pixel", "A distance on screen"}, \
  {PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned", ""}, \
  {PROP_PERCENTAGE, "PERCENTAGE", 0, "Percentage", "A percentage between 0 and 100"}, \
  {PROP_FACTOR, "FACTOR", 0, "Factor", "A factor between 0.0 and 1.0"}, \
  {PROP_ANGLE, "ANGLE", 0, "Angle", "A rotational value specified in radians"}, \
  {PROP_TIME, "TIME", 0, "Time (Scene Relative)", \
   "Time specified in frames, converted to seconds based on scene frame rate"}, \
  {PROP_TIME_ABSOLUTE, "TIME_ABSOLUTE", 0, "Time (Absolute)", \
   "Time specified in seconds, independent of the scene"}, \
  {PROP_DISTANCE, "DISTANCE", 0, "Distance", "A distance between two points"}, \
  {PROP_DISTANCE_CAMERA, "DISTANCE_CAMERA", 0, "Camera Distance", ""}, \
  {PROP_POWER, "POWER", 0, "Power", ""}, \
  {PROP_TEMPERATURE, "TEMPERATURE", 0, "Temperature", ""}, \
  {PROP_WAVELENGTH, "WAVELENGTH", 0, "Wavelength", ""}, \
  {PROP_COLOR_TEMPERATURE, "COLOR_TEMPERATURE", 0, "Color Temperature", ""}, \
  {PROP_FREQUENCY, "FREQUENCY", 0, "Frequency", ""}
 
#define RNA_ENUM_PROPERTY_SUBTYPE_NUMBER_ARRAY_ITEMS \
  {PROP_COLOR, "COLOR", 0, "Linear Color", "Color in the linear space"}, \
  {PROP_TRANSLATION, "TRANSLATION", 0, "Translation", "Color in the gamma corrected space"}, \
  {PROP_DIRECTION, "DIRECTION", 0, "Direction", ""}, \
  {PROP_VELOCITY, "VELOCITY", 0, "Velocity", ""}, \
  {PROP_ACCELERATION, "ACCELERATION", 0, "Acceleration", ""}, \
  {PROP_MATRIX, "MATRIX", 0, "Matrix", ""}, \
  {PROP_EULER, "EULER", 0, "Euler Angles", "Euler rotation angles in radians"}, \
  {PROP_QUATERNION, "QUATERNION", 0, "Quaternion", "Quaternion rotation (affects NLA blending)"}, \
  {PROP_AXISANGLE, "AXISANGLE", 0, "Axis-Angle", "Angle and axis to rotate around"}, \
  {PROP_XYZ, "XYZ", 0, "XYZ", ""}, \
  {PROP_XYZ_LENGTH, "XYZ_LENGTH", 0, "XYZ Length", ""}, \
  {PROP_COLOR_GAMMA, "COLOR_GAMMA", 0, "Gamma-Corrected Color", ""}, \
  {PROP_COORDS, "COORDINATES", 0, "Coordinates", ""}, \
  /* Boolean. */ \
  {PROP_LAYER, "LAYER", 0, "Layer", ""}, \
  {PROP_LAYER_MEMBER, "LAYER_MEMBER", 0, "Layer Member", ""}
 
/* clang-format on */
 
const EnumPropertyItem rna_enum_property_subtype_string_items[] = {
    RNA_ENUM_PROPERTY_SUBTYPE_STRING_ITEMS,
 
    {PROP_NONE, "NONE", 0, "None", ""},
    {0, nullptr, 0, nullptr, nullptr},
};
 
const EnumPropertyItem rna_enum_property_subtype_number_items[] = {
    RNA_ENUM_PROPERTY_SUBTYPE_NUMBER_ITEMS,
 
    {PROP_NONE, "NONE", 0, "None", ""},
    {0, nullptr, 0, nullptr, nullptr},
};
 
const EnumPropertyItem rna_enum_property_subtype_number_array_items[] = {
    RNA_ENUM_PROPERTY_SUBTYPE_NUMBER_ARRAY_ITEMS,
 
    {PROP_NONE, "NONE", 0, "None", ""},
    {0, nullptr, 0, nullptr, nullptr},
};
 
const EnumPropertyItem rna_enum_property_subtype_items[] = {
    {PROP_NONE, "NONE", 0, "None", ""},
 
    /* String. */
    RNA_ENUM_PROPERTY_SUBTYPE_STRING_ITEMS,
 
    /* Number. */
    RNA_ENUM_PROPERTY_SUBTYPE_NUMBER_ITEMS,
 
    /* Number array. */
    RNA_ENUM_PROPERTY_SUBTYPE_NUMBER_ARRAY_ITEMS,
 
    {0, nullptr, 0, nullptr, nullptr},
};
 
const EnumPropertyItem rna_enum_property_unit_items[] = {
    {PROP_UNIT_NONE, "NONE", 0, "None", ""},
    {PROP_UNIT_LENGTH, "LENGTH", 0, "Length", ""},
    {PROP_UNIT_AREA, "AREA", 0, "Area", ""},
    {PROP_UNIT_VOLUME, "VOLUME", 0, "Volume", ""},
    {PROP_UNIT_ROTATION, "ROTATION", 0, "Rotation", ""},
    {PROP_UNIT_TIME, "TIME", 0, "Time (Scene Relative)", ""},
    {PROP_UNIT_TIME_ABSOLUTE, "TIME_ABSOLUTE", 0, "Time (Absolute)", ""},
    {PROP_UNIT_VELOCITY, "VELOCITY", 0, "Velocity", ""},
    {PROP_UNIT_ACCELERATION, "ACCELERATION", 0, "Acceleration", ""},
    {PROP_UNIT_MASS, "MASS", 0, "Mass", ""},
    {PROP_UNIT_CAMERA, "CAMERA", 0, "Camera", ""},
    {PROP_UNIT_POWER, "POWER", 0, "Power", ""},
    {PROP_UNIT_TEMPERATURE, "TEMPERATURE", 0, "Temperature", ""},
    {PROP_UNIT_WAVELENGTH, "WAVELENGTH", 0, "Wavelength", ""},
    {PROP_UNIT_COLOR_TEMPERATURE, "COLOR_TEMPERATURE", 0, "Color Temperature", ""},
    {PROP_UNIT_FREQUENCY, "FREQUENCY", 0, "Frequency", ""},
    {0, nullptr, 0, nullptr, nullptr},
};
 
/* Descriptions for rna_enum_property_flag_items and rna_enum_property_flag_enum_items. */
static constexpr auto PROP_HIDDEN_DESCR =
    "For operators: hide from places in the user interface where Blender would add the property "
    "automatically, like Adjust Last Operation. Also this property is not written to presets.";
static constexpr auto PROP_SKIP_SAVE_DESCR =
    "For operators: the value of this property will not be remembered between invocations of the "
    "operator; instead, each invocation will start by using the default value. Also this "
    "property is not written to presets.";
static constexpr auto PROP_SKIP_PRESET_DESCR = "Do not write in presets";
static constexpr auto PROP_ANIMATABLE_DESCR = "";
static constexpr auto PROP_LIB_EXCEPTION_DESCR =
    "This property can be edited, even when it is used on linked data (which normally is "
    "read-only). Note that edits to the property will not be saved to the blend file.";
static constexpr auto PROP_PROPORTIONAL_DESCR = "";
static constexpr auto PROP_TEXTEDIT_UPDATE_DESCR = "";
static constexpr auto PROP_PATH_OUTPUT_DESCR = "";
static constexpr auto PROP_ENUM_FLAG_DESCR = "";
 
const EnumPropertyItem rna_enum_property_flag_items[] = {
    {PROP_HIDDEN, "HIDDEN", 0, "Hidden", PROP_HIDDEN_DESCR},
    {PROP_SKIP_SAVE, "SKIP_SAVE", 0, "Skip Save", PROP_SKIP_SAVE_DESCR},
    {PROP_SKIP_PRESET, "SKIP_PRESET", 0, "Skip Preset", PROP_SKIP_PRESET_DESCR},
    {PROP_ANIMATABLE, "ANIMATABLE", 0, "Animatable", PROP_ANIMATABLE_DESCR},
    {PROP_LIB_EXCEPTION, "LIBRARY_EDITABLE", 0, "Library Editable", PROP_LIB_EXCEPTION_DESCR},
    {PROP_PROPORTIONAL,
     "PROPORTIONAL",
     0,
     "Adjust values proportionally to each other",
     PROP_PROPORTIONAL_DESCR},
    {int(PROP_TEXTEDIT_UPDATE),
     "TEXTEDIT_UPDATE",
     0,
     "Update on every keystroke in textedit 'mode'",
     PROP_TEXTEDIT_UPDATE_DESCR},
    {PROP_PATH_OUTPUT, "OUTPUT_PATH", 0, "Output Path", PROP_PATH_OUTPUT_DESCR},
    {0, nullptr, 0, nullptr, nullptr},
};
 
const EnumPropertyItem rna_enum_property_flag_enum_items[] = {
    {PROP_HIDDEN, "HIDDEN", 0, "Hidden", PROP_HIDDEN_DESCR},
    {PROP_SKIP_SAVE, "SKIP_SAVE", 0, "Skip Save", PROP_SKIP_SAVE_DESCR},
    {PROP_ANIMATABLE, "ANIMATABLE", 0, "Animatable", PROP_ANIMATABLE_DESCR},
    {PROP_LIB_EXCEPTION, "LIBRARY_EDITABLE", 0, "Library Editable", PROP_LIB_EXCEPTION_DESCR},
    {PROP_ENUM_FLAG, "ENUM_FLAG", 0, "Enum Flag", PROP_ENUM_FLAG_DESCR},
    {0, nullptr, 0, nullptr, nullptr},
};
 
static const EnumPropertyItem rna_enum_property_item_library_overridable{
    PROPOVERRIDE_OVERRIDABLE_LIBRARY,
    "LIBRARY_OVERRIDABLE",
    0,
    "Library Overridable",
    "Make that property editable in library overrides of linked data-blocks.\n"
    "NOTE: For a property to be overridable, its whole chain of parent properties must also be "
    "defined as overridable"};
 
const EnumPropertyItem rna_enum_property_override_flag_items[] = {
    rna_enum_property_item_library_overridable,
    {0, nullptr, 0, nullptr, nullptr},
};
 
const EnumPropertyItem rna_enum_property_override_flag_collection_items[] = {
    rna_enum_property_item_library_overridable,
    {PROPOVERRIDE_NO_PROP_NAME,
     "NO_PROPERTY_NAME",
     0,
     "No Name",
     "Do not use the names of the items, only their indices in the collection"},
    {PROPOVERRIDE_LIBRARY_INSERTION,
     "USE_INSERTION",
     0,
     "Use Insertion",
     "Allow users to add new items in that collection in library overrides"},
    {0, nullptr, 0, nullptr, nullptr},
};
 
const EnumPropertyItem rna_enum_property_string_search_flag_items[] = {
    {PROP_STRING_SEARCH_SORT, "SORT", 0, "Sort Search Results", ""},
    {PROP_STRING_SEARCH_SUGGESTION,
     "SUGGESTION",
     0,
     "Suggestion",
     "Search results are suggestions (other values may be entered)"},
 
    {0, nullptr, 0, nullptr, nullptr},
};
 
#ifdef RNA_RUNTIME
#  include "BLI_ghash.h"
#  include "BLI_string.h"
#  include "MEM_guardedalloc.h"
 
#  include "BKE_idprop.hh"
#  include "BKE_lib_override.hh"
 
#  include "RNA_path.hh"
 
#  include <optional>
#  include <string>
 
#  include <fmt/format.h>
 
static CLG_LogRef LOG_COMPARE_OVERRIDE = {"rna.rna_compare_override"};
 
/* Struct */
 
static void rna_Struct_identifier_get(PointerRNA *ptr, char *value)
{
  strcpy(value, ((StructRNA *)ptr->data)->identifier);
}
 
static int rna_Struct_identifier_length(PointerRNA *ptr)
{
  return strlen(((StructRNA *)ptr->data)->identifier);
}
 
static void rna_Struct_description_get(PointerRNA *ptr, char *value)
{
  strcpy(value, ((StructRNA *)ptr->data)->description);
}
 
static int rna_Struct_description_length(PointerRNA *ptr)
{
  return strlen(((StructRNA *)ptr->data)->description);
}
 
static void rna_Struct_name_get(PointerRNA *ptr, char *value)
{
  strcpy(value, ((StructRNA *)ptr->data)->name);
}
 
static int rna_Struct_name_length(PointerRNA *ptr)
{
  return strlen(((StructRNA *)ptr->data)->name);
}
 
static void rna_Struct_translation_context_get(PointerRNA *ptr, char *value)
{
  strcpy(value, ((StructRNA *)ptr->data)->translation_context);
}
 
static int rna_Struct_translation_context_length(PointerRNA *ptr)
{
  return strlen(((StructRNA *)ptr->data)->translation_context);
}
 
static PointerRNA rna_Struct_base_get(PointerRNA *ptr)
{
  return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((StructRNA *)ptr->data)->base);
}
 
static PointerRNA rna_Struct_nested_get(PointerRNA *ptr)
{
  return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((StructRNA *)ptr->data)->nested);
}
 
static PointerRNA rna_Struct_name_property_get(PointerRNA *ptr)
{
  return rna_pointer_inherit_refine(ptr, &RNA_Property, ((StructRNA *)ptr->data)->nameproperty);
}
 
/* Struct property iteration. This is quite complicated, the purpose is to
 * iterate over properties of all inheritance levels, and for each struct to
 * also iterator over id properties not known by RNA. */
 
static bool rna_idproperty_known(CollectionPropertyIterator *iter, void *data)
{
  IDProperty *idprop = (IDProperty *)data;
  PropertyRNA *prop;
  StructRNA *ptype = iter->builtin_parent.type;
 
  /* Function to skip any id properties that are already known by RNA,
   * for the second loop where we go over unknown id properties.
   *
   * Note that only dynamically-defined RNA properties (the ones actually using IDProperties as
   * storage back-end) should be checked here. If a custom property is named the same as a 'normal'
   * RNA property, they are different data. */
  do {
    for (prop = static_cast<PropertyRNA *>(ptype->cont.properties.first); prop; prop = prop->next)
    {
      if ((prop->flag_internal & PROP_INTERN_BUILTIN) == 0 &&
          (prop->flag & PROP_IDPROPERTY) != 0 && STREQ(prop->identifier, idprop->name))
      {
        return true;
      }
    }
  } while ((ptype = ptype->base));
 
  return false;
}
 
static bool rna_property_builtin(CollectionPropertyIterator * /*iter*/, void *data)
{
  PropertyRNA *prop = (PropertyRNA *)data;
 
  /* function to skip builtin rna properties */
 
  return (prop->flag_internal & PROP_INTERN_BUILTIN) != 0;
}
 
static bool rna_function_builtin(CollectionPropertyIterator * /*iter*/, void *data)
{
  FunctionRNA *func = (FunctionRNA *)data;
 
  /* function to skip builtin rna functions */
 
  return (func->flag & FUNC_BUILTIN) != 0;
}
 
static void rna_inheritance_next_level_restart(CollectionPropertyIterator *iter,
                                               IteratorSkipFunc skip,
                                               int funcs)
{
  /* RNA struct inheritance */
  while (!iter->valid && iter->level > 0) {
    StructRNA *srna;
    int i;
 
    srna = (StructRNA *)iter->parent.data;
    iter->level--;
    for (i = iter->level; i > 0; i--) {
      srna = srna->base;
    }
 
    rna_iterator_listbase_end(iter);
 
    if (funcs) {
      rna_iterator_listbase_begin(iter, &srna->functions, skip);
    }
    else {
      rna_iterator_listbase_begin(iter, &srna->cont.properties, skip);
    }
  }
}
 
static void rna_inheritance_properties_listbase_begin(CollectionPropertyIterator *iter,
                                                      ListBase *lb,
                                                      IteratorSkipFunc skip)
{
  rna_iterator_listbase_begin(iter, lb, skip);
  rna_inheritance_next_level_restart(iter, skip, 0);
}
 
static void rna_inheritance_properties_listbase_next(CollectionPropertyIterator *iter,
                                                     IteratorSkipFunc skip)
{
  rna_iterator_listbase_next(iter);
  rna_inheritance_next_level_restart(iter, skip, 0);
}
 
static void rna_inheritance_functions_listbase_begin(CollectionPropertyIterator *iter,
                                                     ListBase *lb,
                                                     IteratorSkipFunc skip)
{
  rna_iterator_listbase_begin(iter, lb, skip);
  rna_inheritance_next_level_restart(iter, skip, 1);
}
 
static void rna_inheritance_functions_listbase_next(CollectionPropertyIterator *iter,
                                                    IteratorSkipFunc skip)
{
  rna_iterator_listbase_next(iter);
  rna_inheritance_next_level_restart(iter, skip, 1);
}
 
static void rna_Struct_properties_next(CollectionPropertyIterator *iter)
{
  ListBaseIterator *internal = &iter->internal.listbase;
  IDProperty *group;
 
  if (internal->flag) {
    /* id properties */
    rna_iterator_listbase_next(iter);
  }
  else {
    /* regular properties */
    rna_inheritance_properties_listbase_next(iter, rna_property_builtin);
 
    /* try id properties */
    if (!iter->valid) {
      group = RNA_struct_idprops(&iter->builtin_parent, 0);
 
      if (group) {
        rna_iterator_listbase_end(iter);
        rna_iterator_listbase_begin(iter, &group->data.group, rna_idproperty_known);
        internal = &iter->internal.listbase;
        internal->flag = 1;
      }
    }
  }
}
 
static void rna_Struct_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
{
  StructRNA *srna;
 
  /* here ptr->data should always be the same as iter->parent.type */
  srna = (StructRNA *)ptr->data;
 
  while (srna->base) {
    iter->level++;
    srna = srna->base;
  }
 
  rna_inheritance_properties_listbase_begin(iter, &srna->cont.properties, rna_property_builtin);
}
 
static PointerRNA rna_Struct_properties_get(CollectionPropertyIterator *iter)
{
  ListBaseIterator *internal = &iter->internal.listbase;
 
  /* we return either PropertyRNA* or IDProperty*, the rna_access.cc
   * functions can handle both as PropertyRNA* with some tricks */
  return rna_pointer_inherit_refine(&iter->parent, &RNA_Property, internal->link);
}
 
static void rna_Struct_functions_next(CollectionPropertyIterator *iter)
{
  rna_inheritance_functions_listbase_next(iter, rna_function_builtin);
}
 
static void rna_Struct_functions_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
{
  StructRNA *srna;
 
  /* here ptr->data should always be the same as iter->parent.type */
  srna = (StructRNA *)ptr->data;
 
  while (srna->base) {
    iter->level++;
    srna = srna->base;
  }
 
  rna_inheritance_functions_listbase_begin(iter, &srna->functions, rna_function_builtin);
}
 
static PointerRNA rna_Struct_functions_get(CollectionPropertyIterator *iter)
{
  ListBaseIterator *internal = &iter->internal.listbase;
 
  /* we return either PropertyRNA* or IDProperty*, the rna_access.cc
   * functions can handle both as PropertyRNA* with some tricks */
  return rna_pointer_inherit_refine(&iter->parent, &RNA_Function, internal->link);
}
 
static void rna_Struct_property_tags_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
{
  /* here ptr->data should always be the same as iter->parent.type */
  StructRNA *srna = (StructRNA *)ptr->data;
  const EnumPropertyItem *tag_defines = RNA_struct_property_tag_defines(srna);
  uint tag_count = tag_defines ? RNA_enum_items_count(tag_defines) : 0;
 
  rna_iterator_array_begin(
      iter, (void *)tag_defines, sizeof(EnumPropertyItem), tag_count, 0, nullptr);
}
 
/* Builtin properties iterator re-uses the Struct properties iterator, only
 * difference is that we need to set the ptr data to the type of the struct
 * whose properties we want to iterate over. */
 
void rna_builtin_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
{
  PointerRNA newptr;
 
  /* we create a new pointer with the type as the data */
  newptr.type = &RNA_Struct;
  newptr.data = ptr->type;
 
  if (ptr->type->flag & STRUCT_ID) {
    newptr.owner_id = static_cast<ID *>(ptr->data);
  }
  else {
    newptr.owner_id = nullptr;
  }
 
  iter->parent = newptr;
  iter->builtin_parent = *ptr;
 
  rna_Struct_properties_begin(iter, &newptr);
}
 
void rna_builtin_properties_next(CollectionPropertyIterator *iter)
{
  rna_Struct_properties_next(iter);
}
 
PointerRNA rna_builtin_properties_get(CollectionPropertyIterator *iter)
{
  return rna_Struct_properties_get(iter);
}
 
bool rna_builtin_properties_lookup_string(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
{
  StructRNA *srna;
  PropertyRNA *prop;
  PointerRNA propptr = {nullptr};
 
  srna = ptr->type;
 
  do {
    if (srna->cont.prophash) {
      prop = static_cast<PropertyRNA *>(BLI_ghash_lookup(srna->cont.prophash, (void *)key));
 
      if (prop) {
        propptr.type = &RNA_Property;
        propptr.data = prop;
 
        *r_ptr = propptr;
        return true;
      }
    }
    else {
      for (prop = static_cast<PropertyRNA *>(srna->cont.properties.first); prop; prop = prop->next)
      {
        if (!(prop->flag_internal & PROP_INTERN_BUILTIN) && STREQ(prop->identifier, key)) {
          propptr.type = &RNA_Property;
          propptr.data = prop;
 
          *r_ptr = propptr;
          return true;
        }
      }
    }
  } while ((srna = srna->base));
  return false;
}
 
PointerRNA rna_builtin_type_get(PointerRNA *ptr)
{
  return rna_pointer_inherit_refine(ptr, &RNA_Struct, ptr->type);
}
 
/* Property */
 
static StructRNA *rna_Property_refine(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
 
  switch (RNA_property_type(prop)) {
    case PROP_BOOLEAN:
      return &RNA_BoolProperty;
    case PROP_INT:
      return &RNA_IntProperty;
    case PROP_FLOAT:
      return &RNA_FloatProperty;
    case PROP_STRING:
      return &RNA_StringProperty;
    case PROP_ENUM:
      return &RNA_EnumProperty;
    case PROP_POINTER:
      return &RNA_PointerProperty;
    case PROP_COLLECTION:
      return &RNA_CollectionProperty;
    default:
      return &RNA_Property;
  }
}
 
static void rna_Property_identifier_get(PointerRNA *ptr, char *value)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  strcpy(value, RNA_property_identifier(prop));
}
 
static int rna_Property_identifier_length(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return strlen(RNA_property_identifier(prop));
}
 
static void rna_Property_name_get(PointerRNA *ptr, char *value)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  const char *name = RNA_property_ui_name_raw(prop);
  strcpy(value, name ? name : "");
}
 
static int rna_Property_name_length(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  const char *name = RNA_property_ui_name_raw(prop);
  return name ? strlen(name) : 0;
}
 
static void rna_Property_description_get(PointerRNA *ptr, char *value)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  const char *description = RNA_property_ui_description_raw(prop);
  strcpy(value, description ? description : "");
}
static int rna_Property_description_length(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  const char *description = RNA_property_ui_description_raw(prop);
  return description ? strlen(description) : 0;
}
 
static void rna_Property_translation_context_get(PointerRNA *ptr, char *value)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  strcpy(value, RNA_property_translation_context(prop));
}
 
static int rna_Property_translation_context_length(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return strlen(RNA_property_translation_context(prop));
}
 
static int rna_Property_type_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return RNA_property_type(prop);
}
 
static int rna_Property_subtype_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return RNA_property_subtype(prop);
}
 
static PointerRNA rna_Property_srna_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return rna_pointer_inherit_refine(ptr, &RNA_Struct, prop->srna);
}
 
static int rna_Property_unit_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return RNA_property_unit(prop);
}
 
static int rna_Property_icon_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return RNA_property_ui_icon(prop);
}
 
static bool rna_Property_readonly_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
 
  /* don't use this because it will call functions that check the internal
   * data for introspection we only need to know if it can be edited so the
   * flag is better for this */
  // return RNA_property_editable(ptr, prop);
  return (prop->flag & PROP_EDITABLE) == 0;
}
 
static bool rna_Property_animatable_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
 
  return (prop->flag & PROP_ANIMATABLE) != 0;
}
 
static bool rna_Property_overridable_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
 
  IDProperty *idprop = rna_idproperty_check(&prop, ptr);
 
  return idprop != nullptr ? (idprop->flag & IDP_FLAG_OVERRIDABLE_LIBRARY) != 0 :
                             (prop->flag_override & PROPOVERRIDE_OVERRIDABLE_LIBRARY) != 0;
}
 
static bool rna_Property_use_output_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return (prop->flag_parameter & PARM_OUTPUT) != 0;
}
 
static bool rna_Property_is_required_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return (prop->flag_parameter & PARM_REQUIRED) != 0;
}
 
static bool rna_Property_is_argument_optional_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return (prop->flag_parameter & PARM_PYFUNC_OPTIONAL) != 0;
}
 
static bool rna_Property_is_never_none_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return (prop->flag & PROP_NEVER_NULL) != 0;
}
 
static bool rna_Property_is_hidden_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return (prop->flag & PROP_HIDDEN) != 0;
}
 
static bool rna_Property_is_skip_save_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return (prop->flag & PROP_SKIP_SAVE) != 0;
}
 
static bool rna_Property_is_skip_preset_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return (prop->flag & (PROP_SKIP_SAVE | PROP_HIDDEN | PROP_SKIP_PRESET)) != 0;
}
 
static bool rna_Property_is_enum_flag_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return (prop->flag & PROP_ENUM_FLAG) != 0;
}
 
static bool rna_Property_is_library_editable_flag_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return (prop->flag & PROP_LIB_EXCEPTION) != 0;
}
 
static bool rna_Property_is_path_output_flag_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return (prop->flag & PROP_PATH_OUTPUT) != 0;
}
 
static int rna_Property_tags_get(PointerRNA *ptr)
{
  return RNA_property_tags(static_cast<PropertyRNA *>(ptr->data));
}
 
static const EnumPropertyItem *rna_Property_tags_itemf(bContext * /*C*/,
                                                       PointerRNA *ptr,
                                                       PropertyRNA * /*prop*/,
                                                       bool *r_free)
{
  PropertyRNA *this_prop = (PropertyRNA *)ptr->data;
  const StructRNA *srna = RNA_property_pointer_type(ptr, this_prop);
  EnumPropertyItem *prop_tags;
  EnumPropertyItem tmp = {0, "", 0, "", ""};
  int totitem = 0;
 
  for (const EnumPropertyItem *struct_tags = RNA_struct_property_tag_defines(srna);
       struct_tags != nullptr && struct_tags->identifier != nullptr;
       struct_tags++)
  {
    memcpy(&tmp, struct_tags, sizeof(tmp));
    RNA_enum_item_add(&prop_tags, &totitem, &tmp);
  }
  RNA_enum_item_end(&prop_tags, &totitem);
  *r_free = true;
 
  return prop_tags;
}
 
static int rna_Property_array_length_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return prop->totarraylength;
}
 
static void rna_Property_array_dimensions_get(PointerRNA *ptr,
                                              int dimensions[RNA_MAX_ARRAY_DIMENSION])
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
 
  if (prop->arraydimension > 1) {
    for (int i = RNA_MAX_ARRAY_DIMENSION; i--;) {
      dimensions[i] = (i >= prop->arraydimension) ? 0 : prop->arraylength[i];
    }
  }
  else {
    memset(dimensions, 0, sizeof(*dimensions) * RNA_MAX_ARRAY_DIMENSION);
    dimensions[0] = prop->totarraylength;
  }
}
 
static bool rna_Property_is_registered_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return (prop->flag & PROP_REGISTER) != 0;
}
 
static bool rna_Property_is_registered_optional_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return (prop->flag & PROP_REGISTER_OPTIONAL) != 0;
}
 
static bool rna_Property_is_runtime_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  return RNA_property_is_runtime(prop);
}
 
static bool rna_BoolProperty_default_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return ((BoolPropertyRNA *)prop)->defaultvalue;
}
 
static int rna_IntProperty_default_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return ((IntPropertyRNA *)prop)->defaultvalue;
}
/* int/float/bool */
static int rna_NumberProperty_default_array_get_length(const PointerRNA *ptr,
                                                       int length[RNA_MAX_ARRAY_DIMENSION])
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
 
  length[0] = prop->totarraylength;
 
  return length[0];
}
static bool rna_NumberProperty_is_array_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
 
  return RNA_property_array_check(prop);
}
 
static void rna_IntProperty_default_array_get(PointerRNA *ptr, int *values)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  if (prop->totarraylength > 0) {
    PointerRNA null_ptr = PointerRNA_NULL;
    RNA_property_int_get_default_array(&null_ptr, prop, values);
  }
}
 
static void rna_BoolProperty_default_array_get(PointerRNA *ptr, bool *values)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  if (prop->totarraylength > 0) {
    PointerRNA null_ptr = PointerRNA_NULL;
    RNA_property_boolean_get_default_array(&null_ptr, prop, values);
  }
}
 
static void rna_FloatProperty_default_array_get(PointerRNA *ptr, float *values)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  if (prop->totarraylength > 0) {
    PointerRNA null_ptr = PointerRNA_NULL;
    RNA_property_float_get_default_array(&null_ptr, prop, values);
  }
}
 
static int rna_IntProperty_hard_min_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return ((IntPropertyRNA *)prop)->hardmin;
}
 
static int rna_IntProperty_hard_max_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return ((IntPropertyRNA *)prop)->hardmax;
}
 
static int rna_IntProperty_soft_min_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return ((IntPropertyRNA *)prop)->softmin;
}
 
static int rna_IntProperty_soft_max_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return ((IntPropertyRNA *)prop)->softmax;
}
 
static int rna_IntProperty_step_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return ((IntPropertyRNA *)prop)->step;
}
 
static float rna_FloatProperty_default_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return ((FloatPropertyRNA *)prop)->defaultvalue;
}
static float rna_FloatProperty_hard_min_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return ((FloatPropertyRNA *)prop)->hardmin;
}
 
static float rna_FloatProperty_hard_max_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return ((FloatPropertyRNA *)prop)->hardmax;
}
 
static float rna_FloatProperty_soft_min_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return ((FloatPropertyRNA *)prop)->softmin;
}
 
static float rna_FloatProperty_soft_max_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return ((FloatPropertyRNA *)prop)->softmax;
}
 
static float rna_FloatProperty_step_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return ((FloatPropertyRNA *)prop)->step;
}
 
static int rna_FloatProperty_precision_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return ((FloatPropertyRNA *)prop)->precision;
}
 
static void rna_StringProperty_default_get(PointerRNA *ptr, char *value)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  strcpy(value, ((StringPropertyRNA *)prop)->defaultvalue);
}
static int rna_StringProperty_default_length(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return strlen(((StringPropertyRNA *)prop)->defaultvalue);
}
 
static int rna_StringProperty_max_length_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return ((StringPropertyRNA *)prop)->maxlength;
}
 
static const EnumPropertyItem *rna_EnumProperty_default_itemf(bContext *C,
                                                              PointerRNA *ptr,
                                                              PropertyRNA *prop_parent,
                                                              bool *r_free)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  EnumPropertyRNA *eprop;
 
  prop = rna_ensure_property(prop);
  eprop = (EnumPropertyRNA *)prop;
 
  /* incompatible default attributes */
  if ((prop_parent->flag & PROP_ENUM_FLAG) != (prop->flag & PROP_ENUM_FLAG)) {
    return rna_enum_dummy_NULL_items;
  }
 
  if ((eprop->item_fn == nullptr) || (eprop->item_fn == rna_EnumProperty_default_itemf) ||
      (ptr->type == &RNA_EnumProperty) || (C == nullptr))
  {
    if (eprop->item) {
      return eprop->item;
    }
  }
 
  return eprop->item_fn(C, ptr, prop, r_free);
}
 
/* XXX: not sure this is needed? */
static int rna_EnumProperty_default_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return ((EnumPropertyRNA *)prop)->defaultvalue;
}
 
static bool rna_enum_check_separator(CollectionPropertyIterator * /*iter*/, void *data)
{
  EnumPropertyItem *item = (EnumPropertyItem *)data;
 
  return (item->identifier[0] == 0);
}
 
static void rna_EnumProperty_items_begin_impl(CollectionPropertyIterator *iter,
                                              PointerRNA *ptr,
                                              IteratorSkipFunc skip_fn)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  // EnumPropertyRNA *eprop; /* UNUSED */
  const EnumPropertyItem *item = nullptr;
  int totitem;
  bool free;
 
  prop = rna_ensure_property(prop);
  // eprop = (EnumPropertyRNA *)prop;
 
  RNA_property_enum_items_ex(nullptr,
                             ptr,
                             prop,
                             STREQ(iter->prop->identifier, "enum_items_static"),
                             &item,
                             &totitem,
                             &free);
  rna_iterator_array_begin(iter, (void *)item, sizeof(EnumPropertyItem), totitem, free, skip_fn);
}
 
static void rna_EnumProperty_items_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
{
  rna_EnumProperty_items_begin_impl(iter, ptr, rna_enum_check_separator);
}
 
static void rna_EnumProperty_items_ui_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
{
  /* No skip-function, include all "UI" items. */
  rna_EnumProperty_items_begin_impl(iter, ptr, nullptr);
}
 
static void rna_EnumPropertyItem_identifier_get(PointerRNA *ptr, char *value)
{
  strcpy(value, ((EnumPropertyItem *)ptr->data)->identifier);
}
 
static int rna_EnumPropertyItem_identifier_length(PointerRNA *ptr)
{
  return strlen(((EnumPropertyItem *)ptr->data)->identifier);
}
 
static void rna_EnumPropertyItem_name_get(PointerRNA *ptr, char *value)
{
  const EnumPropertyItem *eprop = static_cast<const EnumPropertyItem *>(ptr->data);
  /* Name can be nullptr in the case of separators
   * which are exposed via `_bpy.rna_enum_items_static`. */
  if (eprop->name) {
    strcpy(value, eprop->name);
  }
  else {
    value[0] = '\0';
  }
}
 
static int rna_EnumPropertyItem_name_length(PointerRNA *ptr)
{
  const EnumPropertyItem *eprop = static_cast<const EnumPropertyItem *>(ptr->data);
  if (eprop->name) {
    return strlen(eprop->name);
  }
  return 0;
}
 
static void rna_EnumPropertyItem_description_get(PointerRNA *ptr, char *value)
{
  const EnumPropertyItem *eprop = static_cast<const EnumPropertyItem *>(ptr->data);
 
  if (eprop->description) {
    strcpy(value, eprop->description);
  }
  else {
    value[0] = '\0';
  }
}
 
static int rna_EnumPropertyItem_description_length(PointerRNA *ptr)
{
  EnumPropertyItem *eprop = (EnumPropertyItem *)ptr->data;
 
  if (eprop->description) {
    return strlen(eprop->description);
  }
  return 0;
}
 
static int rna_EnumPropertyItem_value_get(PointerRNA *ptr)
{
  return ((EnumPropertyItem *)ptr->data)->value;
}
 
static int rna_EnumPropertyItem_icon_get(PointerRNA *ptr)
{
  return ((EnumPropertyItem *)ptr->data)->icon;
}
 
static PointerRNA rna_PointerProperty_fixed_type_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((PointerPropertyRNA *)prop)->type);
}
 
static PointerRNA rna_CollectionProperty_fixed_type_get(PointerRNA *ptr)
{
  PropertyRNA *prop = (PropertyRNA *)ptr->data;
  prop = rna_ensure_property(prop);
  return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((CollectionPropertyRNA *)prop)->item_type);
}
 
/* Function */
 
static void rna_Function_identifier_get(PointerRNA *ptr, char *value)
{
  strcpy(value, ((FunctionRNA *)ptr->data)->identifier);
}
 
static int rna_Function_identifier_length(PointerRNA *ptr)
{
  return strlen(((FunctionRNA *)ptr->data)->identifier);
}
 
static void rna_Function_description_get(PointerRNA *ptr, char *value)
{
  strcpy(value, ((FunctionRNA *)ptr->data)->description);
}
 
static int rna_Function_description_length(PointerRNA *ptr)
{
  return strlen(((FunctionRNA *)ptr->data)->description);
}
 
static void rna_Function_parameters_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
{
  rna_iterator_listbase_begin(
      iter, &((FunctionRNA *)ptr->data)->cont.properties, rna_property_builtin);
}
 
static bool rna_Function_registered_get(PointerRNA *ptr)
{
  FunctionRNA *func = (FunctionRNA *)ptr->data;
  return 0 != (func->flag & FUNC_REGISTER);
}
 
static bool rna_Function_registered_optional_get(PointerRNA *ptr)
{
  FunctionRNA *func = (FunctionRNA *)ptr->data;
  return 0 != (func->flag & (FUNC_REGISTER_OPTIONAL & ~FUNC_REGISTER));
}
 
static bool rna_Function_no_self_get(PointerRNA *ptr)
{
  FunctionRNA *func = (FunctionRNA *)ptr->data;
  return !(func->flag & FUNC_NO_SELF);
}
 
static bool rna_Function_use_self_type_get(PointerRNA *ptr)
{
  FunctionRNA *func = (FunctionRNA *)ptr->data;
  return 0 != (func->flag & FUNC_USE_SELF_TYPE);
}
 
/* Blender RNA */
 
static bool rna_struct_is_publc(CollectionPropertyIterator * /*iter*/, void *data)
{
  StructRNA *srna = static_cast<StructRNA *>(data);
 
  return !(srna->flag & STRUCT_PUBLIC_NAMESPACE);
}
 
static void rna_BlenderRNA_structs_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
{
  BlenderRNA *brna = static_cast<BlenderRNA *>(ptr->data);
  rna_iterator_listbase_begin(iter, &brna->structs, rna_struct_is_publc);
}
 
/* optional, for faster lookups */
static int rna_BlenderRNA_structs_length(PointerRNA *ptr)
{
  BlenderRNA *brna = static_cast<BlenderRNA *>(ptr->data);
  BLI_assert(brna->structs_len == BLI_listbase_count(&brna->structs));
  return brna->structs_len;
}
static bool rna_BlenderRNA_structs_lookup_int(PointerRNA *ptr, int index, PointerRNA *r_ptr)
{
  BlenderRNA *brna = static_cast<BlenderRNA *>(ptr->data);
  StructRNA *srna = static_cast<StructRNA *>(
      index < brna->structs_len ? BLI_findlink(&brna->structs, index) : nullptr);
  if (srna != nullptr) {
    *r_ptr = RNA_pointer_create(nullptr, &RNA_Struct, srna);
    return true;
  }
  else {
    return false;
  }
}
static bool rna_BlenderRNA_structs_lookup_string(PointerRNA *ptr,
                                                 const char *key,
                                                 PointerRNA *r_ptr)
{
  BlenderRNA *brna = static_cast<BlenderRNA *>(ptr->data);
  StructRNA *srna = static_cast<StructRNA *>(BLI_ghash_lookup(brna->structs_map, (void *)key));
  if (srna != nullptr) {
    *r_ptr = RNA_pointer_create(nullptr, &RNA_Struct, srna);
    return true;
  }
 
  return false;
}
 
/* Default override (and compare) callbacks. */
 
struct RNACompareOverrideDiffPropPtrContext {
  RNAPropertyOverrideDiffContext &rnadiff_ctx;
 
  ID *owner_id_a = nullptr;
  ID *owner_id_b = nullptr;
  PointerRNA propptr_a = {0};
  PointerRNA propptr_b = {0};
  PropertyType property_type = PROP_BOOLEAN;
 
  bool no_ownership = false;
  bool no_prop_name = false;
  bool do_force_name = false;
  bool use_id_pointer = false;
 
  bool has_liboverride_apply_cb = false;
 
  /* NOTE: names (and ID pointers, in case items are ID pointers) are typically set by a call
   * to #rna_property_override_diff_propptr_validate_diffing. Indices are typically set directly
   * from the loop over all RNA collections items in #rna_property_override_diff_default. */
  std::optional<std::string> rna_itemname_a;
  std::optional<std::string> rna_itemname_b;
  std::optional<ID *> rna_itemid_a;
  std::optional<ID *> rna_itemid_b;
  int rna_itemindex_a = -1;
  int rna_itemindex_b = -1;
 
  bool is_valid_for_diffing = true;
 
  bool is_id = false;
  bool is_null = false;
  bool is_type_diff = false;
 
  RNACompareOverrideDiffPropPtrContext(RNAPropertyOverrideDiffContext &rnadiff_ctx_)
      : rnadiff_ctx(rnadiff_ctx_)
  {
  }
};
static void rna_property_override_diff_propptr_validate_diffing(
    RNACompareOverrideDiffPropPtrContext &ptrdiff_ctx)
{
  PointerRNA *propptr_a = &ptrdiff_ctx.propptr_a;
  PointerRNA *propptr_b = &ptrdiff_ctx.propptr_b;
  const bool no_ownership = ptrdiff_ctx.no_ownership;
  const bool no_prop_name = ptrdiff_ctx.no_prop_name;
  const bool do_force_name = ptrdiff_ctx.do_force_name;
 
  ptrdiff_ctx.is_valid_for_diffing = true;
 
  BLI_assert(propptr_a != nullptr);
 
  if (do_force_name || ptrdiff_ctx.use_id_pointer) {
    BLI_assert(!no_prop_name);
  }
 
  /* Beware, PointerRNA_NULL has no type and is considered a 'blank page'! */
  if (ELEM(nullptr, propptr_a->type, propptr_a->data)) {
    if (ELEM(nullptr, propptr_b, propptr_b->type, propptr_b->data)) {
      ptrdiff_ctx.is_null = true;
    }
    else {
      ptrdiff_ctx.is_id = RNA_struct_is_ID(propptr_b->type);
      ptrdiff_ctx.is_null = true;
      ptrdiff_ctx.is_type_diff = propptr_a->type != propptr_b->type;
    }
    ptrdiff_ctx.is_valid_for_diffing = false;
  }
  else {
    ptrdiff_ctx.is_id = RNA_struct_is_ID(propptr_a->type);
    ptrdiff_ctx.is_null = (ELEM(nullptr, propptr_b, propptr_b->type, propptr_b->data));
    ptrdiff_ctx.is_type_diff = (propptr_b == nullptr || propptr_b->type != propptr_a->type);
    ptrdiff_ctx.is_valid_for_diffing = !((ptrdiff_ctx.is_id && no_ownership) ||
                                         ptrdiff_ctx.is_null || ptrdiff_ctx.is_type_diff);
  }
 
  /* We do a generic quick first comparison checking for "name" and/or "type" properties.
   * We assume that is any of those are false, then we are not handling the same data.
   * This helps a lot in library override case, especially to detect inserted items in collections.
   */
  if (!no_prop_name && (ptrdiff_ctx.is_valid_for_diffing || do_force_name)) {
    PropertyRNA *nameprop_a = (propptr_a->type != nullptr) ?
                                  RNA_struct_name_property(propptr_a->type) :
                                  nullptr;
    PropertyRNA *nameprop_b = (propptr_b != nullptr && propptr_b->type != nullptr) ?
                                  RNA_struct_name_property(propptr_b->type) :
                                  nullptr;
    const bool do_id_pointer = ptrdiff_ctx.use_id_pointer && ptrdiff_ctx.is_id;
 
    /* NOTE: Until we have a `std::string` version of `RNA_property_string_get`, these C string
     * pointers and buffers are needed here. Otherwise, in case of C string allocation, if the
     * result of `RNA_property_string_get` is directly assigned to a `std::string`, there is no way
     * to free this memory. */
    int rna_itemname_a_len = 0, rna_itemname_b_len = 0;
    char *rna_itemname_a = nullptr;
    char *rna_itemname_b = nullptr;
    char buff_a[4096];
    char buff_b[4096];
    if (nameprop_a != nullptr) {
      rna_itemname_a = RNA_property_string_get_alloc(
          propptr_a, nameprop_a, buff_a, sizeof(buff_a), &rna_itemname_a_len);
      //          printf("rna_itemname_a = %s\n", rna_itemname_a ? rna_itemname_a : "<NONE>");
      ptrdiff_ctx.rna_itemname_a = rna_itemname_a;
    }
    //      else printf("item of type %s a has no name property!\n", propptr_a->type->name);
    if (nameprop_b != nullptr) {
      rna_itemname_b = RNA_property_string_get_alloc(
          propptr_b, nameprop_b, buff_b, sizeof(buff_b), &rna_itemname_b_len);
      ptrdiff_ctx.rna_itemname_b = rna_itemname_b;
    }
 
    /* NOTE: This will always assign nullptr to these lib-pointers in case `do_id_lib` is false,
     * which ensures that they will not affect the result of `ptrdiff_ctx.is_valid_for_diffing` in
     * the last check below. */
    ID *rna_itemid_a = (do_id_pointer && propptr_a->data) ? static_cast<ID *>(propptr_a->data) :
                                                            nullptr;
    ID *rna_itemid_b = (do_id_pointer && propptr_b->data) ? static_cast<ID *>(propptr_b->data) :
                                                            nullptr;
    if (do_id_pointer) {
      ptrdiff_ctx.rna_itemid_a = rna_itemid_a;
      ptrdiff_ctx.rna_itemid_b = rna_itemid_b;
    }
 
    if (rna_itemname_a != nullptr && rna_itemname_b != nullptr) {
      if (rna_itemid_a != rna_itemid_b || rna_itemname_a_len != rna_itemname_b_len ||
          rna_itemname_a[0] != rna_itemname_b[0] || !STREQ(rna_itemname_a, rna_itemname_b))
      {
        ptrdiff_ctx.is_valid_for_diffing = false;
        //              printf("%s: different names\n", rna_path ? rna_path : "<UNKNOWN>");
      }
    }
    if (UNLIKELY(rna_itemname_a && rna_itemname_a != buff_a)) {
      MEM_freeN(rna_itemname_a);
    }
    if (UNLIKELY(rna_itemname_b && rna_itemname_b != buff_b)) {
      MEM_freeN(rna_itemname_b);
    }
  }
 
  if (ptrdiff_ctx.is_id) {
    BLI_assert(propptr_a->data == propptr_a->owner_id && propptr_b->data == propptr_b->owner_id);
  }
}
 
/* Used for both Pointer and Collection properties. */
static void rna_property_override_diff_propptr(Main *bmain,
                                               RNACompareOverrideDiffPropPtrContext &ptrdiff_ctx)
{
  ID *owner_id_a = ptrdiff_ctx.owner_id_a;
  ID *owner_id_b = ptrdiff_ctx.owner_id_b;
  PointerRNA *propptr_a = &ptrdiff_ctx.propptr_a;
  PointerRNA *propptr_b = &ptrdiff_ctx.propptr_b;
 
  eRNACompareMode mode = ptrdiff_ctx.rnadiff_ctx.mode;
  const bool no_ownership = ptrdiff_ctx.no_ownership;
 
  IDOverrideLibrary *liboverride = ptrdiff_ctx.rnadiff_ctx.liboverride;
  const eRNAOverrideMatch liboverride_flags = ptrdiff_ctx.rnadiff_ctx.liboverride_flags;
  const char *rna_path = ptrdiff_ctx.rnadiff_ctx.rna_path;
  size_t rna_path_len = ptrdiff_ctx.rnadiff_ctx.rna_path_len;
  const PropertyType property_type = ptrdiff_ctx.property_type;
 
  std::optional<std::string> &rna_itemname_a = ptrdiff_ctx.rna_itemname_a;
  std::optional<std::string> &rna_itemname_b = ptrdiff_ctx.rna_itemname_b;
  const int rna_itemindex_a = ptrdiff_ctx.rna_itemindex_a;
  const int rna_itemindex_b = ptrdiff_ctx.rna_itemindex_b;
 
  BLI_assert(ELEM(property_type, PROP_POINTER, PROP_COLLECTION));
 
  rna_property_override_diff_propptr_validate_diffing(ptrdiff_ctx);
 
  /* If false, it means that the whole data itself is different,
   * so no point in going inside of it at all! */
  const bool is_valid_for_diffing = ptrdiff_ctx.is_valid_for_diffing;
  const bool is_id = ptrdiff_ctx.is_id;
  const bool is_null = ptrdiff_ctx.is_null;
  const bool is_type_diff = ptrdiff_ctx.is_type_diff;
 
  const bool has_liboverride_apply_cb = ptrdiff_ctx.has_liboverride_apply_cb;
  const bool do_create = (liboverride != nullptr &&
                          /* Replacing a Pointer can only happen if it's an ID one, or there is a
                           * dedicated apply callback defined for the property. */
                          (is_id || has_liboverride_apply_cb) &&
                          (liboverride_flags & RNA_OVERRIDE_COMPARE_CREATE) != 0 &&
                          rna_path != nullptr);
 
  if (is_id) {
    /* Owned IDs (the ones we want to actually compare in depth, instead of just comparing pointer
     * values) should be always properly tagged as 'virtual' overrides. */
    ID *id = propptr_a->owner_id;
    if (id != nullptr && !ID_IS_OVERRIDE_LIBRARY(id)) {
      id = propptr_b->owner_id;
      if (id != nullptr && !ID_IS_OVERRIDE_LIBRARY(id)) {
        id = nullptr;
      }
    }
 
    BLI_assert(no_ownership || id == nullptr || ID_IS_OVERRIDE_LIBRARY_VIRTUAL(id));
    UNUSED_VARS_NDEBUG(id);
  }
 
  if (liboverride) {
    if (no_ownership || is_null || is_type_diff || !is_valid_for_diffing) {
      /* In case this pointer prop does not own its data (or one is nullptr), do not compare
       * structs! This is a quite safe path to infinite loop, among other nasty issues. Instead,
       * just compare pointers themselves. */
      ptrdiff_ctx.rnadiff_ctx.comparison = (propptr_a->data != propptr_b->data);
 
      if (do_create && ptrdiff_ctx.rnadiff_ctx.comparison != 0) {
        bool created = false;
        IDOverrideLibraryProperty *op = BKE_lib_override_library_property_get(
            liboverride, rna_path, &created);
 
        /* If not yet overridden, or if we are handling sub-items (inside a collection)... */
        if (op != nullptr) {
          if (created || op->rna_prop_type == 0) {
            op->rna_prop_type = property_type;
          }
          else {
            BLI_assert(op->rna_prop_type == property_type);
          }
 
          IDOverrideLibraryPropertyOperation *opop = nullptr;
          if (created || (rna_itemname_a && !rna_itemname_a->empty()) ||
              (rna_itemname_b && !rna_itemname_b->empty()) || rna_itemindex_a != -1 ||
              rna_itemindex_b != -1)
          {
            const char *subitem_refname = rna_itemname_b ? rna_itemname_b->c_str() : nullptr;
            const char *subitem_locname = rna_itemname_a ? rna_itemname_a->c_str() : nullptr;
            opop = BKE_lib_override_library_property_operation_get(op,
                                                                   LIBOVERRIDE_OP_REPLACE,
                                                                   subitem_refname,
                                                                   subitem_locname,
                                                                   ptrdiff_ctx.rna_itemid_b,
                                                                   ptrdiff_ctx.rna_itemid_a,
                                                                   rna_itemindex_b,
                                                                   rna_itemindex_a,
                                                                   true,
                                                                   nullptr,
                                                                   &created);
            /* Do not use BKE_lib_override_library_operations_tag here, we do not want to validate
             * as used all of its operations. */
            op->tag &= ~LIBOVERRIDE_PROP_OP_TAG_UNUSED;
            opop->tag &= ~LIBOVERRIDE_PROP_OP_TAG_UNUSED;
            if (created) {
              ptrdiff_ctx.rnadiff_ctx.report_flag |= RNA_OVERRIDE_MATCH_RESULT_CREATED;
            }
          }
          else {
            BKE_lib_override_library_operations_tag(op, LIBOVERRIDE_PROP_OP_TAG_UNUSED, false);
          }
 
          if (is_id && no_ownership) {
            if (opop == nullptr) {
              const char *subitem_refname = rna_itemname_b ? rna_itemname_b->c_str() : nullptr;
              const char *subitem_locname = rna_itemname_a ? rna_itemname_a->c_str() : nullptr;
              opop = BKE_lib_override_library_property_operation_find(op,
                                                                      subitem_refname,
                                                                      subitem_locname,
                                                                      ptrdiff_ctx.rna_itemid_b,
                                                                      ptrdiff_ctx.rna_itemid_a,
                                                                      rna_itemindex_b,
                                                                      rna_itemindex_a,
                                                                      true,
                                                                      nullptr);
              opop->tag &= ~LIBOVERRIDE_PROP_OP_TAG_UNUSED;
            }
 
            BLI_assert(propptr_a->data == propptr_a->owner_id);
            BLI_assert(propptr_b->data == propptr_b->owner_id);
            ID *id_a = static_cast<ID *>(propptr_a->data);
            ID *id_b = static_cast<ID *>(propptr_b->data);
            if (ELEM(nullptr, id_a, id_b)) {
              /* In case one of the pointer is nullptr and not the other, we consider that the
               * liboverride is not matching its reference anymore. */
              opop->flag &= ~LIBOVERRIDE_OP_FLAG_IDPOINTER_MATCH_REFERENCE;
            }
            else if ((owner_id_a->tag & ID_TAG_LIBOVERRIDE_NEED_RESYNC) != 0 ||
                     (owner_id_b->tag & ID_TAG_LIBOVERRIDE_NEED_RESYNC) != 0)
            {
              /* In case one of the owner of the checked property is tagged as needing resync, do
               * not change the 'match reference' status of its ID pointer properties overrides,
               * since many non-matching ones are likely due to missing resync. */
              CLOG_INFO(&LOG_COMPARE_OVERRIDE,
                        4,
                        "Not checking matching ID pointer properties, since owner %s is tagged as "
                        "needing resync.\n",
                        id_a->name);
            }
            else if (id_a->override_library != nullptr &&
                     id_a->override_library->reference == id_b)
            {
              opop->flag |= LIBOVERRIDE_OP_FLAG_IDPOINTER_MATCH_REFERENCE;
            }
            else if (id_b->override_library != nullptr &&
                     id_b->override_library->reference == id_a)
            {
              opop->flag |= LIBOVERRIDE_OP_FLAG_IDPOINTER_MATCH_REFERENCE;
            }
            else {
              opop->flag &= ~LIBOVERRIDE_OP_FLAG_IDPOINTER_MATCH_REFERENCE;
            }
          }
        }
      }
    }
    else {
/* In case we got some array/collection like items identifiers, now is the time to generate a
 * proper rna path from those. */
#  define RNA_PATH_BUFFSIZE 8192
 
      char extended_rna_path_buffer[RNA_PATH_BUFFSIZE];
      char *extended_rna_path = extended_rna_path_buffer;
      size_t extended_rna_path_len = 0;
 
      /* There may be a propname defined in some cases, while no actual name set
       * (e.g. happens with point cache), in that case too we want to fall back to index.
       * Note that we do not need the RNA path for insertion operations. */
      if (rna_path) {
        if ((rna_itemname_a && !rna_itemname_a->empty()) &&
            (rna_itemname_b && !rna_itemname_b->empty()))
        {
          BLI_assert(*rna_itemname_a == *rna_itemname_b);
 
          char esc_item_name[RNA_PATH_BUFFSIZE];
          const size_t esc_item_name_len = BLI_str_escape(
              esc_item_name, rna_itemname_a->c_str(), sizeof(esc_item_name));
          extended_rna_path_len = rna_path_len + 2 + esc_item_name_len + 2;
          if (extended_rna_path_len >= RNA_PATH_BUFFSIZE) {
            extended_rna_path = static_cast<char *>(
                MEM_mallocN(extended_rna_path_len + 1, __func__));
          }
 
          memcpy(extended_rna_path, rna_path, rna_path_len);
          extended_rna_path[rna_path_len] = '[';
          extended_rna_path[rna_path_len + 1] = '"';
          memcpy(extended_rna_path + rna_path_len + 2, esc_item_name, esc_item_name_len);
          extended_rna_path[rna_path_len + 2 + esc_item_name_len] = '"';
          extended_rna_path[rna_path_len + 2 + esc_item_name_len + 1] = ']';
          extended_rna_path[extended_rna_path_len] = '\0';
        }
        else if (rna_itemindex_a != -1) { /* Based on index... */
          BLI_assert(rna_itemindex_a == rna_itemindex_b);
 
          /* low-level specific highly-efficient conversion of positive integer to string. */
          char item_index_buff[32];
          size_t item_index_buff_len = 0;
          if (rna_itemindex_a == 0) {
            item_index_buff[0] = '0';
            item_index_buff_len = 1;
          }
          else {
            uint index;
            for (index = rna_itemindex_a;
                 index > 0 && item_index_buff_len < sizeof(item_index_buff);
                 index /= 10)
            {
              item_index_buff[item_index_buff_len++] = '0' + char(index % 10);
            }
            BLI_assert(index == 0);
          }
 
          extended_rna_path_len = rna_path_len + item_index_buff_len + 2;
          if (extended_rna_path_len >= RNA_PATH_BUFFSIZE) {
            extended_rna_path = static_cast<char *>(
                MEM_mallocN(extended_rna_path_len + 1, __func__));
          }
 
          memcpy(extended_rna_path, rna_path, rna_path_len);
          extended_rna_path[rna_path_len] = '[';
          for (size_t i = 1; i <= item_index_buff_len; i++) {
            /* The first loop above generated inverted string representation of our index number.
             */
            extended_rna_path[rna_path_len + i] = item_index_buff[item_index_buff_len - i];
          }
          extended_rna_path[rna_path_len + 1 + item_index_buff_len] = ']';
          extended_rna_path[extended_rna_path_len] = '\0';
        }
        else {
          extended_rna_path = (char *)rna_path;
          extended_rna_path_len = rna_path_len;
        }
      }
 
      const bool match = RNA_struct_override_matches(bmain,
                                                     propptr_a,
                                                     propptr_b,
                                                     extended_rna_path,
                                                     extended_rna_path_len,
                                                     liboverride,
                                                     liboverride_flags,
                                                     &ptrdiff_ctx.rnadiff_ctx.report_flag);
      ptrdiff_ctx.rnadiff_ctx.comparison = !match;
 
      /* Regardless of whether the data from both pointers matches or not, a potentially existing
       * operation on current extended rna path should be removed. This is done by tagging said
       * operation as unused, while clearing the property tag (see also
       * #RNA_struct_override_matches handling of #LIBOVERRIDE_PROP_OP_TAG_UNUSED). Note that a
       * property with no operations will also be cleared by
       * #BKE_lib_override_library_id_unused_cleanup. */
      IDOverrideLibraryProperty *op = BKE_lib_override_library_property_find(liboverride,
                                                                             extended_rna_path);
      if (op != nullptr) {
        op->tag &= ~LIBOVERRIDE_PROP_OP_TAG_UNUSED;
      }
 
      if (!ELEM(extended_rna_path, extended_rna_path_buffer, rna_path)) {
        MEM_freeN(extended_rna_path);
      }
 
#  undef RNA_PATH_BUFFSIZE
    }
  }
  else {
    /* We could also use is_diff_pointer, but then we potentially lose the greater-than/less-than
     * info - and don't think performances are critical here for now anyway. */
    ptrdiff_ctx.rnadiff_ctx.comparison = !RNA_struct_equals(bmain, propptr_a, propptr_b, mode);
  }
}
 
#  define RNA_PROPERTY_GET_SINGLE(_typename, _ptr, _prop, _index) \
    (is_array ? RNA_property_##_typename##_get_index((_ptr), (_prop), (_index)) : \
                RNA_property_##_typename##_get((_ptr), (_prop)))
#  define RNA_PROPERTY_SET_SINGLE(_typename, _ptr, _prop, _index, _value) \
    (is_array ? RNA_property_##_typename##_set_index((_ptr), (_prop), (_index), (_value)) : \
                RNA_property_##_typename##_set((_ptr), (_prop), (_value)))
 
void rna_property_override_diff_default(Main *bmain, RNAPropertyOverrideDiffContext &rnadiff_ctx)
{
  PropertyRNAOrID *prop_a = rnadiff_ctx.prop_a;
  PropertyRNAOrID *prop_b = rnadiff_ctx.prop_b;
  PointerRNA *ptr_a = &prop_a->ptr;
  PointerRNA *ptr_b = &prop_b->ptr;
  PropertyRNA *rawprop_a = prop_a->rawprop;
  PropertyRNA *rawprop_b = prop_b->rawprop;
  const uint len_a = prop_a->array_len;
  const uint len_b = prop_b->array_len;
 
  IDOverrideLibrary *liboverride = rnadiff_ctx.liboverride;
  const char *rna_path = rnadiff_ctx.rna_path;
  const int liboverride_flags = rnadiff_ctx.liboverride_flags;
 
  BLI_assert(len_a == len_b);
 
  /* NOTE: at this point, we are sure that when len_a is zero,
   * we are not handling an (empty) array. */
 
  const bool do_create = liboverride != nullptr &&
                         (liboverride_flags & RNA_OVERRIDE_COMPARE_CREATE) != 0 &&
                         rna_path != nullptr;
 
  const bool no_ownership = (prop_a->rnaprop->flag & PROP_PTR_NO_OWNERSHIP) != 0;
 
  const PropertyType rna_prop_type = RNA_property_type(prop_a->rnaprop);
  bool created = false;
  IDOverrideLibraryProperty *op = nullptr;
 
  switch (rna_prop_type) {
    case PROP_BOOLEAN: {
      if (len_a) {
        bool array_stack_a[RNA_STACK_ARRAY], array_stack_b[RNA_STACK_ARRAY];
        bool *array_a, *array_b;
 
        array_a = static_cast<bool *>((len_a > RNA_STACK_ARRAY) ?
                                          MEM_mallocN(sizeof(bool) * len_a, "RNA equals") :
                                          array_stack_a);
        array_b = static_cast<bool *>((len_b > RNA_STACK_ARRAY) ?
                                          MEM_mallocN(sizeof(bool) * len_b, "RNA equals") :
                                          array_stack_b);
 
        RNA_property_boolean_get_array(ptr_a, rawprop_a, array_a);
        RNA_property_boolean_get_array(ptr_b, rawprop_b, array_b);
 
        rnadiff_ctx.comparison = memcmp(array_a, array_b, sizeof(bool) * len_a);
 
        if (do_create && rnadiff_ctx.comparison != 0) {
          /* XXX TODO: this will have to be refined to handle array items. */
          op = BKE_lib_override_library_property_get(liboverride, rna_path, &created);
 
          if (op != nullptr && created) {
            BKE_lib_override_library_property_operation_get(op,
                                                            LIBOVERRIDE_OP_REPLACE,
                                                            nullptr,
                                                            nullptr,
                                                            {},
                                                            {},
                                                            -1,
                                                            -1,
                                                            true,
                                                            nullptr,
                                                            nullptr);
            rnadiff_ctx.report_flag |= RNA_OVERRIDE_MATCH_RESULT_CREATED;
          }
          else {
            /* Already overridden prop, we'll have to check arrays items etc. */
          }
        }
 
        if (array_a != array_stack_a) {
          MEM_freeN(array_a);
        }
        if (array_b != array_stack_b) {
          MEM_freeN(array_b);
        }
      }
      else {
        const bool value_a = RNA_property_boolean_get(ptr_a, rawprop_a);
        const bool value_b = RNA_property_boolean_get(ptr_b, rawprop_b);
        rnadiff_ctx.comparison = (value_a < value_b) ? -1 : (value_a > value_b) ? 1 : 0;
 
        if (do_create && rnadiff_ctx.comparison != 0) {
          op = BKE_lib_override_library_property_get(liboverride, rna_path, &created);
 
          if (op != nullptr && created) { /* If not yet overridden... */
            BKE_lib_override_library_property_operation_get(op,
                                                            LIBOVERRIDE_OP_REPLACE,
                                                            nullptr,
                                                            nullptr,
                                                            {},
                                                            {},
                                                            -1,
                                                            -1,
                                                            true,
                                                            nullptr,
                                                            nullptr);
            rnadiff_ctx.report_flag |= RNA_OVERRIDE_MATCH_RESULT_CREATED;
          }
        }
      }
      break;
    }
 
    case PROP_INT: {
      if (len_a) {
        int array_stack_a[RNA_STACK_ARRAY], array_stack_b[RNA_STACK_ARRAY];
        int *array_a, *array_b;
 
        array_a = static_cast<int *>((len_a > RNA_STACK_ARRAY) ?
                                         MEM_mallocN(sizeof(int) * len_a, "RNA equals") :
                                         array_stack_a);
        array_b = static_cast<int *>((len_b > RNA_STACK_ARRAY) ?
                                         MEM_mallocN(sizeof(int) * len_b, "RNA equals") :
                                         array_stack_b);
 
        RNA_property_int_get_array(ptr_a, rawprop_a, array_a);
        RNA_property_int_get_array(ptr_b, rawprop_b, array_b);
 
        rnadiff_ctx.comparison = memcmp(array_a, array_b, sizeof(int) * len_a);
 
        if (do_create && rnadiff_ctx.comparison != 0) {
          /* XXX TODO: this will have to be refined to handle array items. */
          op = BKE_lib_override_library_property_get(liboverride, rna_path, &created);
 
          if (op != nullptr && created) {
            BKE_lib_override_library_property_operation_get(op,
                                                            LIBOVERRIDE_OP_REPLACE,
                                                            nullptr,
                                                            nullptr,
                                                            {},
                                                            {},
                                                            -1,
                                                            -1,
                                                            true,
                                                            nullptr,
                                                            nullptr);
            if (created) {
              rnadiff_ctx.report_flag |= RNA_OVERRIDE_MATCH_RESULT_CREATED;
            }
          }
          else {
            /* Already overridden prop, we'll have to check arrays items etc. */
          }
        }
 
        if (array_a != array_stack_a) {
          MEM_freeN(array_a);
        }
        if (array_b != array_stack_b) {
          MEM_freeN(array_b);
        }
      }
      else {
        const int value_a = RNA_property_int_get(ptr_a, rawprop_a);
        const int value_b = RNA_property_int_get(ptr_b, rawprop_b);
        rnadiff_ctx.comparison = (value_a < value_b) ? -1 : (value_a > value_b) ? 1 : 0;
 
        if (do_create && rnadiff_ctx.comparison != 0) {
          op = BKE_lib_override_library_property_get(liboverride, rna_path, &created);
 
          if (op != nullptr && created) { /* If not yet overridden... */
            BKE_lib_override_library_property_operation_get(op,
                                                            LIBOVERRIDE_OP_REPLACE,
                                                            nullptr,
                                                            nullptr,
                                                            {},
                                                            {},
                                                            -1,
                                                            -1,
                                                            true,
                                                            nullptr,
                                                            nullptr);
            rnadiff_ctx.report_flag |= RNA_OVERRIDE_MATCH_RESULT_CREATED;
          }
        }
      }
      break;
    }
 
    case PROP_FLOAT: {
      if (len_a) {
        float array_stack_a[RNA_STACK_ARRAY], array_stack_b[RNA_STACK_ARRAY];
        float *array_a, *array_b;
 
        array_a = static_cast<float *>((len_a > RNA_STACK_ARRAY) ?
                                           MEM_mallocN(sizeof(float) * len_a, "RNA equals") :
                                           array_stack_a);
        array_b = static_cast<float *>((len_b > RNA_STACK_ARRAY) ?
                                           MEM_mallocN(sizeof(float) * len_b, "RNA equals") :
                                           array_stack_b);
 
        RNA_property_float_get_array(ptr_a, rawprop_a, array_a);
        RNA_property_float_get_array(ptr_b, rawprop_b, array_b);
 
        rnadiff_ctx.comparison = memcmp(array_a, array_b, sizeof(float) * len_a);
 
        if (do_create && rnadiff_ctx.comparison != 0) {
          /* XXX TODO: this will have to be refined to handle array items. */
          op = BKE_lib_override_library_property_get(liboverride, rna_path, &created);
 
          if (op != nullptr && created) {
            BKE_lib_override_library_property_operation_get(op,
                                                            LIBOVERRIDE_OP_REPLACE,
                                                            nullptr,
                                                            nullptr,
                                                            {},
                                                            {},
                                                            -1,
                                                            -1,
                                                            true,
                                                            nullptr,
                                                            nullptr);
            rnadiff_ctx.report_flag |= RNA_OVERRIDE_MATCH_RESULT_CREATED;
          }
          else {
            /* Already overridden prop, we'll have to check arrays items etc. */
          }
        }
 
        if (array_a != array_stack_a) {
          MEM_freeN(array_a);
        }
        if (array_b != array_stack_b) {
          MEM_freeN(array_b);
        }
      }
      else {
        const float value_a = RNA_property_float_get(ptr_a, rawprop_a);
        const float value_b = RNA_property_float_get(ptr_b, rawprop_b);
        rnadiff_ctx.comparison = (value_a < value_b) ? -1 : (value_a > value_b) ? 1 : 0;
 
        if (do_create && rnadiff_ctx.comparison != 0) {
          op = BKE_lib_override_library_property_get(liboverride, rna_path, &created);
 
          if (op != nullptr && created) { /* If not yet overridden... */
            BKE_lib_override_library_property_operation_get(op,
                                                            LIBOVERRIDE_OP_REPLACE,
                                                            nullptr,
                                                            nullptr,
                                                            {},
                                                            {},
                                                            -1,
                                                            -1,
                                                            true,
                                                            nullptr,
                                                            nullptr);
            rnadiff_ctx.report_flag |= RNA_OVERRIDE_MATCH_RESULT_CREATED;
          }
        }
      }
      break;
    }
 
    case PROP_ENUM: {
      const int value_a = RNA_property_enum_get(ptr_a, rawprop_a);
      const int value_b = RNA_property_enum_get(ptr_b, rawprop_b);
      rnadiff_ctx.comparison = value_a != value_b;
 
      if (do_create && rnadiff_ctx.comparison != 0) {
        op = BKE_lib_override_library_property_get(liboverride, rna_path, &created);
 
        if (op != nullptr && created) { /* If not yet overridden... */
          BKE_lib_override_library_property_operation_get(op,
                                                          LIBOVERRIDE_OP_REPLACE,
                                                          nullptr,
                                                          nullptr,
                                                          {},
                                                          {},
                                                          -1,
                                                          -1,
                                                          true,
                                                          nullptr,
                                                          nullptr);
          rnadiff_ctx.report_flag |= RNA_OVERRIDE_MATCH_RESULT_CREATED;
        }
      }
      break;
    }
 
    case PROP_STRING: {
      char fixed_a[4096], fixed_b[4096];
      int len_str_a, len_str_b;
      char *value_a = RNA_property_string_get_alloc(
          ptr_a, rawprop_a, fixed_a, sizeof(fixed_a), &len_str_a);
      char *value_b = RNA_property_string_get_alloc(
          ptr_b, rawprop_b, fixed_b, sizeof(fixed_b), &len_str_b);
/* TODO: we could do a check on length too,
 * but then we would not have a 'real' string comparison...
 * Maybe behind a eRNAOverrideMatch flag? */
#  if 0
      rnadiff_ctx.comparison = len_str_a < len_str_b ? -1 :
                               len_str_a > len_str_b ? 1 :
                                                       strcmp(value_a, value_b);
#  endif
      rnadiff_ctx.comparison = strcmp(value_a, value_b);
 
      if (do_create && rnadiff_ctx.comparison != 0) {
        op = BKE_lib_override_library_property_get(liboverride, rna_path, &created);
 
        if (op != nullptr && created) { /* If not yet overridden... */
          BKE_lib_override_library_property_operation_get(op,
                                                          LIBOVERRIDE_OP_REPLACE,
                                                          nullptr,
                                                          nullptr,
                                                          {},
                                                          {},
                                                          -1,
                                                          -1,
                                                          true,
                                                          nullptr,
                                                          nullptr);
          rnadiff_ctx.report_flag |= RNA_OVERRIDE_MATCH_RESULT_CREATED;
        }
      }
 
      if (value_a != fixed_a) {
        MEM_freeN(value_a);
      }
      if (value_b != fixed_b) {
        MEM_freeN(value_b);
      }
      break;
    }
 
    case PROP_POINTER: {
      /* Using property name check only makes sense for items of a collection, not for a single
       * pointer.
       * Doing this here avoids having to manually specify `PROPOVERRIDE_NO_PROP_NAME` to things
       * like ShapeKey pointers. */
      if (STREQ(prop_a->identifier, "rna_type")) {
        /* Dummy 'pass' answer, this is a meta-data and must be ignored... */
        return;
      }
      else {
        RNACompareOverrideDiffPropPtrContext ptrdiff_ctx(rnadiff_ctx);
        ptrdiff_ctx.owner_id_a = ptr_a->owner_id;
        ptrdiff_ctx.owner_id_b = ptr_b->owner_id;
        ptrdiff_ctx.propptr_a = RNA_property_pointer_get(ptr_a, rawprop_a);
        ptrdiff_ctx.propptr_b = RNA_property_pointer_get(ptr_b, rawprop_b);
        ptrdiff_ctx.no_prop_name = true;
        ptrdiff_ctx.no_ownership = no_ownership;
        ptrdiff_ctx.property_type = PROP_POINTER;
        /* IDProperties (real or backend storage for dynamic RNA) have a default handling for
         * 'pointer' data creation. */
        if (prop_a->is_idprop || prop_a->is_rna_storage_idprop || prop_a->rnaprop->override_apply)
        {
          BLI_assert(prop_a->is_idprop == prop_b->is_idprop);
          BLI_assert(prop_a->rnaprop->override_apply == prop_b->rnaprop->override_apply);
          BLI_assert(prop_a->rnaprop->override_apply == prop_b->rnaprop->override_apply);
          ptrdiff_ctx.has_liboverride_apply_cb = true;
        }
        rna_property_override_diff_propptr(bmain, ptrdiff_ctx);
      }
      break;
    }
 
    case PROP_COLLECTION: {
      const bool no_prop_name = (prop_a->rnaprop->flag_override & PROPOVERRIDE_NO_PROP_NAME) != 0;
 
      /* IDProperties (real or backend storage for dynamic RNA) have a default handling for
       * 'pointer' data creation and 'collection' items insertion. */
      BLI_assert(prop_a->is_idprop == prop_b->is_idprop);
      BLI_assert(prop_a->is_rna_storage_idprop == prop_b->is_rna_storage_idprop);
      BLI_assert(prop_a->rnaprop->override_apply == prop_b->rnaprop->override_apply);
      const bool has_liboverride_apply_cb = (prop_a->is_idprop || prop_a->is_rna_storage_idprop ||
                                             prop_a->rnaprop->override_apply);
      if (!has_liboverride_apply_cb &&
          (prop_a->rnaprop->flag_override & PROPOVERRIDE_LIBRARY_INSERTION) != 0)
      {
        CLOG_ERROR(&LOG_COMPARE_OVERRIDE,
                   "RNA collection '%s' defined as supporting liboverride insertion of items, but "
                   "no liboverride apply callback defined for it. No insertion will happen.",
                   rna_path);
      }
 
      /* NOTE: we assume we only insert in ptr_a (i.e. we can only get new items in ptr_a),
       * and that we never remove anything. */
      const bool use_collection_insertion = has_liboverride_apply_cb && do_create &&
                                            (prop_a->rnaprop->flag_override &
                                             PROPOVERRIDE_LIBRARY_INSERTION) != 0;
 
      bool equals = true;
      bool abort = false;
      int idx_a = 0;
      int idx_b = 0;
      std::optional<std::string> prev_rna_itemname_a;
      std::optional<ID *> prev_rna_itemid_a;
 
      CollectionPropertyIterator iter_a, iter_b;
      RNA_property_collection_begin(ptr_a, rawprop_a, &iter_a);
      RNA_property_collection_begin(ptr_b, rawprop_b, &iter_b);
 
      if (use_collection_insertion) {
        /* We need to clean up all possible existing insertion operations, and then re-generate
         * them, otherwise we'd end up with a mess of opop's every time something changes. */
        op = BKE_lib_override_library_property_find(liboverride, rna_path);
        if (op != nullptr) {
          LISTBASE_FOREACH_MUTABLE (IDOverrideLibraryPropertyOperation *, opop, &op->operations) {
            if (ELEM(opop->operation, LIBOVERRIDE_OP_INSERT_AFTER, LIBOVERRIDE_OP_INSERT_BEFORE)) {
              BKE_lib_override_library_property_operation_delete(op, opop);
            }
          }
          op = nullptr;
        }
      }
 
      for (; iter_a.valid && !abort;) {
        do {
          bool is_valid_for_insertion = use_collection_insertion;
 
          RNACompareOverrideDiffPropPtrContext ptrdiff_ctx(rnadiff_ctx);
          ptrdiff_ctx.owner_id_a = ptr_a->owner_id;
          ptrdiff_ctx.owner_id_b = ptr_b->owner_id;
          ptrdiff_ctx.propptr_a = iter_a.ptr;
          if (iter_b.valid) {
            ptrdiff_ctx.propptr_b = iter_b.ptr;
          }
          ptrdiff_ctx.no_prop_name = no_prop_name;
          ptrdiff_ctx.do_force_name = !no_prop_name;
          ptrdiff_ctx.use_id_pointer = !no_prop_name;
          ptrdiff_ctx.no_ownership = no_ownership;
          ptrdiff_ctx.property_type = PROP_COLLECTION;
          ptrdiff_ctx.has_liboverride_apply_cb = has_liboverride_apply_cb;
 
          if (iter_b.valid || use_collection_insertion) {
            rna_property_override_diff_propptr_validate_diffing(ptrdiff_ctx);
            /* Getting props names has already been done in call above, no need to redo it later
             * when calling #rna_property_override_diff_propptr. */
            ptrdiff_ctx.no_prop_name = true;
            ptrdiff_ctx.do_force_name = false;
            ptrdiff_ctx.use_id_pointer = false;
          }
 
          const bool is_valid_for_diffing = ptrdiff_ctx.is_valid_for_diffing;
          const bool is_id = ptrdiff_ctx.is_id;
 
          /* We do not support insertion of IDs for now, neither handle nullptr pointers. */
          if (is_id || is_valid_for_diffing) {
            is_valid_for_insertion = false;
          }
 
#  if 0
          if (rna_path) {
            printf(
                "Checking %s, %s [%d] vs %s [%d]; is_id: %d, diffing: %d; "
                "insert: %d (could be used: %d, do_create: %d)\n",
                rna_path,
                ptrdiff_ctx.rna_itemname_a ? ptrdiff_ctx.rna_itemname_a->c_str() : "",
                idx_a,
                ptrdiff_ctx.rna_itemname_b ? ptrdiff_ctx.rna_itemname_b->c_str() : "",
                idx_b,
                is_id,
                is_valid_for_diffing,
                is_valid_for_insertion,
                use_collection_insertion,
                do_create);
          }
#  endif
 
          if (!(is_id || is_valid_for_diffing || is_valid_for_insertion)) {
            /* Differences we cannot handle, we can break here. */
            equals = false;
            abort = true;
            break;
          }
 
          /* Collections do not support replacement of their data (except for collections of ID
           * pointers), since they do not support removing, only in *some* cases, insertion. We
           * also assume then that _a data is the one where things are inserted.
           *
           * NOTE: In insertion case, both 'local' and 'reference' (aka anchor) sub-item
           * identifiers refer to collection items in the local override. The 'reference' may match
           * an item in the linked reference data, but it can also be another local-only item added
           * by a previous INSERT operation. */
          if (is_valid_for_insertion && use_collection_insertion) {
            op = BKE_lib_override_library_property_get(liboverride, rna_path, &created);
 
            BKE_lib_override_library_property_operation_get(
                op,
                LIBOVERRIDE_OP_INSERT_AFTER,
                (no_prop_name || !prev_rna_itemname_a) ? nullptr : prev_rna_itemname_a->c_str(),
                (no_prop_name || !ptrdiff_ctx.rna_itemname_a) ?
                    nullptr :
                    ptrdiff_ctx.rna_itemname_a->c_str(),
                prev_rna_itemid_a,
                ptrdiff_ctx.rna_itemid_a,
                idx_a - 1,
                idx_a,
                true,
                nullptr,
                nullptr);
#  if 0
            printf("%s: Adding insertion op override after '%s'/%d\n",
                   rna_path,
                   prev_rna_itemname_a ? prev_rna_itemname_a->c_str() : "",
                   idx_a - 1);
#  endif
            op = nullptr;
 
            equals = false;
          }
          else if (is_id || is_valid_for_diffing) {
            if (equals || do_create) {
              ptrdiff_ctx.rna_itemindex_a = idx_a;
              ptrdiff_ctx.rna_itemindex_b = idx_b;
              rna_property_override_diff_propptr(bmain, ptrdiff_ctx);
              equals = equals && (rnadiff_ctx.comparison == 0);
            }
          }
 
          if (ptrdiff_ctx.rna_itemname_a) {
            prev_rna_itemname_a = std::move(*ptrdiff_ctx.rna_itemname_a);
          }
          else {
            prev_rna_itemname_a.reset();
          }
          prev_rna_itemid_a = ptrdiff_ctx.rna_itemid_a;
 
          if (!do_create && !equals) {
            abort = true; /* Early out in case we do not want to loop over whole collection. */
            break;
          }
 
          if (!(use_collection_insertion && !(is_id || is_valid_for_diffing))) {
            break;
          }
 
          if (iter_a.valid) {
            RNA_property_collection_next(&iter_a);
            idx_a++;
          }
        } while (iter_a.valid);
 
        if (iter_a.valid) {
          RNA_property_collection_next(&iter_a);
          idx_a++;
        }
        if (iter_b.valid) {
          RNA_property_collection_next(&iter_b);
          idx_b++;
        }
      }
 
      /* Not same number of items in both collections. */
      equals = equals && !(iter_a.valid || iter_b.valid) && !abort;
      RNA_property_collection_end(&iter_a);
      RNA_property_collection_end(&iter_b);
 
      rnadiff_ctx.comparison = (equals == false);
      return;
    }
 
    default:
      break;
  }
 
  if (op != nullptr) {
    /* In theory, if the liboverride operation already existed, it should already be of the right
     * type. However, in some rare cases a same exact RNA path can end up pointing at different
     * data of a different path than when the liboverride property was created, so just always
     * ensure the type is now valid. */
    op->rna_prop_type = rna_prop_type;
  }
 
  return;
}
 
bool rna_property_override_store_default(Main * /*bmain*/,
                                         PointerRNA *ptr_local,
                                         PointerRNA *ptr_reference,
                                         PointerRNA *ptr_storage,
                                         PropertyRNA *prop_local,
                                         PropertyRNA *prop_reference,
                                         PropertyRNA *prop_storage,
                                         const int len_local,
                                         const int len_reference,
                                         const int len_storage,
                                         IDOverrideLibraryPropertyOperation *opop)
{
  BLI_assert(len_local == len_reference && (!ptr_storage || len_local == len_storage));
  UNUSED_VARS_NDEBUG(len_reference, len_storage);
 
  bool changed = false;
  const bool is_array = len_local > 0;
  const int index = is_array ? opop->subitem_reference_index : 0;
 
  if (!ELEM(opop->operation, LIBOVERRIDE_OP_ADD, LIBOVERRIDE_OP_SUBTRACT, LIBOVERRIDE_OP_MULTIPLY))
  {
    return changed;
  }
 
  /* XXX TODO: About range limits.
   * Ideally, it would be great to get rid of RNA range in that specific case.
   * However, this won't be that easy and will add yet another layer of complexity in
   * generated code, not to mention that we could most likely *not* bypass custom setters anyway.
   * So for now, if needed second operand value is not in valid range, we simply fall back
   * to a mere REPLACE operation.
   * Time will say whether this is acceptable limitation or not. */
  switch (RNA_property_type(prop_local)) {
    case PROP_BOOLEAN:
      /* TODO: support boolean ops? Really doubt this would ever be useful though. */
      BLI_assert_msg(0, "Boolean properties support no override diff operation");
      break;
    case PROP_INT: {
      int prop_min, prop_max;
      RNA_property_int_range(ptr_local, prop_local, &prop_min, &prop_max);
 
      if (is_array && index == -1) {
        int array_stack_a[RNA_STACK_ARRAY], array_stack_b[RNA_STACK_ARRAY];
        int *array_a, *array_b;
 
        array_a = static_cast<int *>((len_local > RNA_STACK_ARRAY) ?
                                         MEM_mallocN(sizeof(*array_a) * len_local, __func__) :
                                         array_stack_a);
        RNA_property_int_get_array(ptr_reference, prop_reference, array_a);
 
        switch (opop->operation) {
          case LIBOVERRIDE_OP_ADD:
          case LIBOVERRIDE_OP_SUBTRACT: {
            const int fac = opop->operation == LIBOVERRIDE_OP_ADD ? 1 : -1;
            const int other_op = opop->operation == LIBOVERRIDE_OP_ADD ? LIBOVERRIDE_OP_SUBTRACT :
                                                                         LIBOVERRIDE_OP_ADD;
            bool do_set = true;
            array_b = static_cast<int *>((len_local > RNA_STACK_ARRAY) ?
                                             MEM_mallocN(sizeof(*array_b) * len_local, __func__) :
                                             array_stack_b);
            RNA_property_int_get_array(ptr_local, prop_local, array_b);
            for (int i = len_local; i--;) {
              array_b[i] = fac * (array_b[i] - array_a[i]);
              if (array_b[i] < prop_min || array_b[i] > prop_max) {
                opop->operation = other_op;
                for (int j = len_local; j--;) {
                  array_b[j] = j >= i ? -array_b[j] : fac * (array_a[j] - array_b[j]);
                  if (array_b[j] < prop_min || array_b[j] > prop_max) {
                    /* We failed to find a suitable diff op,
                     * fall back to plain REPLACE one. */
                    opop->operation = LIBOVERRIDE_OP_REPLACE;
                    do_set = false;
                    break;
                  }
                }
                break;
              }
            }
            if (do_set) {
              changed = true;
              RNA_property_int_set_array(ptr_storage, prop_storage, array_b);
            }
            if (array_b != array_stack_b) {
              MEM_freeN(array_b);
            }
            break;
          }
          default:
            BLI_assert_msg(0, "Unsupported RNA override diff operation on integer");
            break;
        }
 
        if (array_a != array_stack_a) {
          MEM_freeN(array_a);
        }
      }
      else {
        const int value = RNA_PROPERTY_GET_SINGLE(int, ptr_reference, prop_reference, index);
 
        switch (opop->operation) {
          case LIBOVERRIDE_OP_ADD:
          case LIBOVERRIDE_OP_SUBTRACT: {
            const int fac = opop->operation == LIBOVERRIDE_OP_ADD ? 1 : -1;
            const int other_op = opop->operation == LIBOVERRIDE_OP_ADD ? LIBOVERRIDE_OP_SUBTRACT :
                                                                         LIBOVERRIDE_OP_ADD;
            int b = fac * (RNA_PROPERTY_GET_SINGLE(int, ptr_local, prop_local, index) - value);
            if (b < prop_min || b > prop_max) {
              opop->operation = other_op;
              b = -b;
              if (b < prop_min || b > prop_max) {
                opop->operation = LIBOVERRIDE_OP_REPLACE;
                break;
              }
            }
            changed = true;
            RNA_PROPERTY_SET_SINGLE(int, ptr_storage, prop_storage, index, b);
            break;
          }
          default:
            BLI_assert_msg(0, "Unsupported RNA override diff operation on integer");
            break;
        }
      }
      break;
    }
    case PROP_FLOAT: {
      float prop_min, prop_max;
      RNA_property_float_range(ptr_local, prop_local, &prop_min, &prop_max);
 
      if (is_array && index == -1) {
        float array_stack_a[RNA_STACK_ARRAY], array_stack_b[RNA_STACK_ARRAY];
        float *array_a, *array_b;
 
        array_a = static_cast<float *>((len_local > RNA_STACK_ARRAY) ?
                                           MEM_mallocN(sizeof(*array_a) * len_local, __func__) :
                                           array_stack_a);
 
        RNA_property_float_get_array(ptr_reference, prop_reference, array_a);
        switch (opop->operation) {
          case LIBOVERRIDE_OP_ADD:
          case LIBOVERRIDE_OP_SUBTRACT: {
            const float fac = opop->operation == LIBOVERRIDE_OP_ADD ? 1.0 : -1.0;
            const int other_op = opop->operation == LIBOVERRIDE_OP_ADD ? LIBOVERRIDE_OP_SUBTRACT :
                                                                         LIBOVERRIDE_OP_ADD;
            bool do_set = true;
            array_b = static_cast<float *>(
                (len_local > RNA_STACK_ARRAY) ?
                    MEM_mallocN(sizeof(*array_b) * len_local, __func__) :
                    array_stack_b);
            RNA_property_float_get_array(ptr_local, prop_local, array_b);
            for (int i = len_local; i--;) {
              array_b[i] = fac * (array_b[i] - array_a[i]);
              if (array_b[i] < prop_min || array_b[i] > prop_max) {
                opop->operation = other_op;
                for (int j = len_local; j--;) {
                  array_b[j] = j >= i ? -array_b[j] : fac * (array_a[j] - array_b[j]);
                  if (array_b[j] < prop_min || array_b[j] > prop_max) {
                    /* We failed to find a suitable diff op,
                     * fall back to plain REPLACE one. */
                    opop->operation = LIBOVERRIDE_OP_REPLACE;
                    do_set = false;
                    break;
                  }
                }
                break;
              }
            }
            if (do_set) {
              changed = true;
              RNA_property_float_set_array(ptr_storage, prop_storage, array_b);
            }
            if (array_b != array_stack_b) {
              MEM_freeN(array_b);
            }
            break;
          }
          case LIBOVERRIDE_OP_MULTIPLY: {
            bool do_set = true;
            array_b = static_cast<float *>(
                (len_local > RNA_STACK_ARRAY) ?
                    MEM_mallocN(sizeof(*array_b) * len_local, __func__) :
                    array_stack_b);
            RNA_property_float_get_array(ptr_local, prop_local, array_b);
            for (int i = len_local; i--;) {
              array_b[i] = array_a[i] == 0.0f ? array_b[i] : array_b[i] / array_a[i];
              if (array_b[i] < prop_min || array_b[i] > prop_max) {
                opop->operation = LIBOVERRIDE_OP_REPLACE;
                do_set = false;
                break;
              }
            }
            if (do_set) {
              changed = true;
              RNA_property_float_set_array(ptr_storage, prop_storage, array_b);
            }
            if (array_b != array_stack_b) {
              MEM_freeN(array_b);
            }
            break;
          }
          default:
            BLI_assert_msg(0, "Unsupported RNA override diff operation on float");
            break;
        }
 
        if (array_a != array_stack_a) {
          MEM_freeN(array_a);
        }
      }
      else {
        const float value = RNA_PROPERTY_GET_SINGLE(float, ptr_reference, prop_reference, index);
 
        switch (opop->operation) {
          case LIBOVERRIDE_OP_ADD:
          case LIBOVERRIDE_OP_SUBTRACT: {
            const float fac = opop->operation == LIBOVERRIDE_OP_ADD ? 1.0f : -1.0f;
            const int other_op = opop->operation == LIBOVERRIDE_OP_ADD ? LIBOVERRIDE_OP_SUBTRACT :
                                                                         LIBOVERRIDE_OP_ADD;
            float b = fac * (RNA_PROPERTY_GET_SINGLE(float, ptr_local, prop_local, index) - value);
            if (b < prop_min || b > prop_max) {
              opop->operation = other_op;
              b = -b;
              if (b < prop_min || b > prop_max) {
                opop->operation = LIBOVERRIDE_OP_REPLACE;
                break;
              }
            }
            changed = true;
            RNA_PROPERTY_SET_SINGLE(float, ptr_storage, prop_storage, index, b);
            break;
          }
          case LIBOVERRIDE_OP_MULTIPLY: {
            const float b = RNA_property_float_get_index(ptr_local, prop_local, index) /
                            (value == 0.0f ? 1.0f : value);
            if (b < prop_min || b > prop_max) {
              opop->operation = LIBOVERRIDE_OP_REPLACE;
              break;
            }
            changed = true;
            RNA_property_float_set_index(ptr_storage, prop_storage, index, b);
            break;
          }
          default:
            BLI_assert_msg(0, "Unsupported RNA override diff operation on float");
            break;
        }
      }
      return true;
    }
    case PROP_ENUM:
      /* TODO: support add/sub, for bitflags? */
      BLI_assert_msg(0, "Enum properties support no override diff operation");
      break;
    case PROP_POINTER:
      BLI_assert_msg(0, "Pointer properties support no override diff operation");
      break;
    case PROP_STRING:
      BLI_assert_msg(0, "String properties support no override diff operation");
      break;
    case PROP_COLLECTION:
      /* XXX TODO: support this of course... */
      BLI_assert_msg(0, "Collection properties support no override diff operation");
      break;
    default:
      break;
  }
 
  return changed;
}
 
bool rna_property_override_apply_default(Main *bmain,
                                         RNAPropertyOverrideApplyContext &rnaapply_ctx)
{
  PointerRNA *ptr_dst = &rnaapply_ctx.ptr_dst;
  PointerRNA *ptr_src = &rnaapply_ctx.ptr_src;
  PointerRNA *ptr_storage = &rnaapply_ctx.ptr_storage;
  PropertyRNA *prop_dst = rnaapply_ctx.prop_dst;
  PropertyRNA *prop_src = rnaapply_ctx.prop_src;
  PropertyRNA *prop_storage = rnaapply_ctx.prop_storage;
  const int len_dst = rnaapply_ctx.len_src;
  const int len_src = rnaapply_ctx.len_src;
  const int len_storage = rnaapply_ctx.len_storage;
  IDOverrideLibraryPropertyOperation *opop = rnaapply_ctx.liboverride_operation;
 
  const PropertyType prop_src_type = RNA_property_type(prop_src);
  const PropertyType prop_dst_type = RNA_property_type(prop_dst);
 
  /* It is possible that a same exact RNA path points to a different property of a different type
   * (due to changes in the program, or in some custom data...). */
  if (prop_src_type != prop_dst_type ||
      (prop_storage && prop_src_type != RNA_property_type(prop_storage)))
  {
    std::optional<std::string> prop_rna_path = rnaapply_ctx.liboverride_property ?
                                                   rnaapply_ctx.liboverride_property->rna_path :
                                                   RNA_path_from_ID_to_property(ptr_dst, prop_dst);
    CLOG_WARN(&LOG_COMPARE_OVERRIDE,
              "%s.%s: Inconsistency between stored property type (%d) and linked reference one "
              "(%d), skipping liboverride apply",
              ptr_dst->owner_id->name,
              prop_rna_path ? prop_rna_path->c_str() :
                              fmt::format(" ... .{}", prop_dst->name).c_str(),
              prop_src_type,
              prop_dst_type);
    /* Keep the liboverride property, update its type to the new actual one. */
    if (rnaapply_ctx.liboverride_property) {
      rnaapply_ctx.liboverride_property->rna_prop_type = prop_dst_type;
    }
    return false;
  }
 
  BLI_assert(len_dst == len_src && (!prop_storage || len_dst == len_storage));
  UNUSED_VARS_NDEBUG(len_src, len_storage);
 
  const bool is_array = len_dst > 0;
  const int index = is_array ? opop->subitem_reference_index : 0;
  const short override_op = opop->operation;
 
  bool ret_success = true;
 
  switch (RNA_property_type(prop_dst)) {
    case PROP_BOOLEAN:
      if (is_array && index == -1) {
        bool array_stack_a[RNA_STACK_ARRAY];
        bool *array_a;
 
        array_a = static_cast<bool *>((len_dst > RNA_STACK_ARRAY) ?
                                          MEM_mallocN(sizeof(*array_a) * len_dst, __func__) :
                                          array_stack_a);
 
        RNA_property_boolean_get_array(ptr_src, prop_src, array_a);
 
        switch (override_op) {
          case LIBOVERRIDE_OP_REPLACE:
            RNA_property_boolean_set_array(ptr_dst, prop_dst, array_a);
            break;
          default:
            BLI_assert_msg(0, "Unsupported RNA override operation on boolean");
            return false;
        }
 
        if (array_a != array_stack_a) {
          MEM_freeN(array_a);
        }
      }
      else {
        const bool value = RNA_PROPERTY_GET_SINGLE(boolean, ptr_src, prop_src, index);
 
        switch (override_op) {
          case LIBOVERRIDE_OP_REPLACE:
            RNA_PROPERTY_SET_SINGLE(boolean, ptr_dst, prop_dst, index, value);
            break;
          default:
            BLI_assert_msg(0, "Unsupported RNA override operation on boolean");
            return false;
        }
      }
      break;
    case PROP_INT:
      if (is_array && index == -1) {
        int array_stack_a[RNA_STACK_ARRAY], array_stack_b[RNA_STACK_ARRAY];
        int *array_a, *array_b;
 
        array_a = static_cast<int *>((len_dst > RNA_STACK_ARRAY) ?
                                         MEM_mallocN(sizeof(*array_a) * len_dst, __func__) :
                                         array_stack_a);
 
        switch (override_op) {
          case LIBOVERRIDE_OP_REPLACE:
            RNA_property_int_get_array(ptr_src, prop_src, array_a);
            RNA_property_int_set_array(ptr_dst, prop_dst, array_a);
            break;
          case LIBOVERRIDE_OP_ADD:
          case LIBOVERRIDE_OP_SUBTRACT:
            RNA_property_int_get_array(ptr_dst, prop_dst, array_a);
            array_b = static_cast<int *>((len_dst > RNA_STACK_ARRAY) ?
                                             MEM_mallocN(sizeof(*array_b) * len_dst, __func__) :
                                             array_stack_b);
            RNA_property_int_get_array(ptr_storage, prop_storage, array_b);
            if (override_op == LIBOVERRIDE_OP_ADD) {
              for (int i = len_dst; i--;) {
                array_a[i] += array_b[i];
              }
            }
            else {
              for (int i = len_dst; i--;) {
                array_a[i] -= array_b[i];
              }
            }
            RNA_property_int_set_array(ptr_dst, prop_dst, array_a);
            if (array_b != array_stack_b) {
              MEM_freeN(array_b);
            }
            break;
          default:
            BLI_assert_msg(0, "Unsupported RNA override operation on integer");
            return false;
        }
 
        if (array_a != array_stack_a) {
          MEM_freeN(array_a);
        }
      }
      else {
        const int storage_value = prop_storage ? RNA_PROPERTY_GET_SINGLE(
                                                     int, ptr_storage, prop_storage, index) :
                                                 0;
 
        switch (override_op) {
          case LIBOVERRIDE_OP_REPLACE:
            RNA_PROPERTY_SET_SINGLE(int,
                                    ptr_dst,
                                    prop_dst,
                                    index,
                                    RNA_PROPERTY_GET_SINGLE(int, ptr_src, prop_src, index));
            break;
          case LIBOVERRIDE_OP_ADD:
            RNA_PROPERTY_SET_SINGLE(int,
                                    ptr_dst,
                                    prop_dst,
                                    index,
                                    RNA_PROPERTY_GET_SINGLE(int, ptr_dst, prop_dst, index) -
                                        storage_value);
            break;
          case LIBOVERRIDE_OP_SUBTRACT:
            RNA_PROPERTY_SET_SINGLE(int,
                                    ptr_dst,
                                    prop_dst,
                                    index,
                                    RNA_PROPERTY_GET_SINGLE(int, ptr_dst, prop_dst, index) -
                                        storage_value);
            break;
          default:
            BLI_assert_msg(0, "Unsupported RNA override operation on integer");
            return false;
        }
      }
      break;
    case PROP_FLOAT:
      if (is_array && index == -1) {
        float array_stack_a[RNA_STACK_ARRAY], array_stack_b[RNA_STACK_ARRAY];
        float *array_a, *array_b;
 
        array_a = static_cast<float *>((len_dst > RNA_STACK_ARRAY) ?
                                           MEM_mallocN(sizeof(*array_a) * len_dst, __func__) :
                                           array_stack_a);
 
        switch (override_op) {
          case LIBOVERRIDE_OP_REPLACE:
            RNA_property_float_get_array(ptr_src, prop_src, array_a);
            RNA_property_float_set_array(ptr_dst, prop_dst, array_a);
            break;
          case LIBOVERRIDE_OP_ADD:
          case LIBOVERRIDE_OP_SUBTRACT:
          case LIBOVERRIDE_OP_MULTIPLY:
            RNA_property_float_get_array(ptr_dst, prop_dst, array_a);
            array_b = static_cast<float *>((len_dst > RNA_STACK_ARRAY) ?
                                               MEM_mallocN(sizeof(*array_b) * len_dst, __func__) :
                                               array_stack_b);
            RNA_property_float_get_array(ptr_storage, prop_storage, array_b);
            if (override_op == LIBOVERRIDE_OP_ADD) {
              for (int i = len_dst; i--;) {
                array_a[i] += array_b[i];
              }
            }
            else if (override_op == LIBOVERRIDE_OP_SUBTRACT) {
              for (int i = len_dst; i--;) {
                array_a[i] -= array_b[i];
              }
            }
            else {
              for (int i = len_dst; i--;) {
                array_a[i] *= array_b[i];
              }
            }
            RNA_property_float_set_array(ptr_dst, prop_dst, array_a);
            if (array_b != array_stack_b) {
              MEM_freeN(array_b);
            }
            break;
          default:
            BLI_assert_msg(0, "Unsupported RNA override operation on float");
            return false;
        }
 
        if (array_a != array_stack_a) {
          MEM_freeN(array_a);
        }
      }
      else {
        const float storage_value = prop_storage ? RNA_PROPERTY_GET_SINGLE(
                                                       float, ptr_storage, prop_storage, index) :
                                                   0.0f;
 
        switch (override_op) {
          case LIBOVERRIDE_OP_REPLACE:
            RNA_PROPERTY_SET_SINGLE(float,
                                    ptr_dst,
                                    prop_dst,
                                    index,
                                    RNA_PROPERTY_GET_SINGLE(float, ptr_src, prop_src, index));
            break;
          case LIBOVERRIDE_OP_ADD:
            RNA_PROPERTY_SET_SINGLE(float,
                                    ptr_dst,
                                    prop_dst,
                                    index,
                                    RNA_PROPERTY_GET_SINGLE(float, ptr_dst, prop_dst, index) +
                                        storage_value);
            break;
          case LIBOVERRIDE_OP_SUBTRACT:
            RNA_PROPERTY_SET_SINGLE(float,
                                    ptr_dst,
                                    prop_dst,
                                    index,
                                    RNA_PROPERTY_GET_SINGLE(float, ptr_dst, prop_dst, index) -
                                        storage_value);
            break;
          case LIBOVERRIDE_OP_MULTIPLY:
            RNA_PROPERTY_SET_SINGLE(float,
                                    ptr_dst,
                                    prop_dst,
                                    index,
                                    RNA_PROPERTY_GET_SINGLE(float, ptr_dst, prop_dst, index) *
                                        storage_value);
            break;
          default:
            BLI_assert_msg(0, "Unsupported RNA override operation on float");
            return false;
        }
      }
      break;
    case PROP_ENUM: {
      const int value = RNA_property_enum_get(ptr_src, prop_src);
 
      switch (override_op) {
        case LIBOVERRIDE_OP_REPLACE:
          RNA_property_enum_set(ptr_dst, prop_dst, value);
          break;
        /* TODO: support add/sub, for bitflags? */
        default:
          BLI_assert_msg(0, "Unsupported RNA override operation on enum");
          return false;
      }
      break;
    }
    case PROP_POINTER: {
      PointerRNA value = RNA_property_pointer_get(ptr_src, prop_src);
 
      switch (override_op) {
        case LIBOVERRIDE_OP_REPLACE:
          RNA_property_pointer_set(ptr_dst, prop_dst, value, nullptr);
          break;
        default:
          BLI_assert_msg(0, "Unsupported RNA override operation on pointer");
          return false;
      }
      break;
    }
    case PROP_STRING: {
      char buff[256];
      char *value = RNA_property_string_get_alloc(ptr_src, prop_src, buff, sizeof(buff), nullptr);
 
      switch (override_op) {
        case LIBOVERRIDE_OP_REPLACE:
          RNA_property_string_set(ptr_dst, prop_dst, value);
          break;
        default:
          BLI_assert_msg(0, "Unsupported RNA override operation on string");
          return false;
      }
 
      if (value != buff) {
        MEM_freeN(value);
      }
      break;
    }
    case PROP_COLLECTION: {
      /* We only support IDProperty-based collection insertion here. */
      const bool is_src_idprop = (prop_src->magic != RNA_MAGIC) ||
                                 (prop_src->flag & PROP_IDPROPERTY) != 0;
      const bool is_dst_idprop = (prop_dst->magic != RNA_MAGIC) ||
                                 (prop_dst->flag & PROP_IDPROPERTY) != 0;
      if (!(is_src_idprop && is_dst_idprop)) {
        CLOG_ERROR(&LOG_COMPARE_OVERRIDE,
                   "'%s': Override operations on RNA collections require a specific override "
                   "apply callback to be defined.",
                   rnaapply_ctx.liboverride_property->rna_path);
        return false;
      }
 
      switch (override_op) {
        case LIBOVERRIDE_OP_INSERT_AFTER: {
          PointerRNA item_ptr_src, item_ptr_ref, item_ptr_dst;
          int item_index_dst;
          bool is_valid = false;
          if (opop->subitem_local_name != nullptr && opop->subitem_local_name[0] != '\0') {
            /* Find from name. */
            int item_index_src, item_index_ref;
            if (RNA_property_collection_lookup_string_index(
                    ptr_src, prop_src, opop->subitem_local_name, &item_ptr_src, &item_index_src) &&
                RNA_property_collection_lookup_string_index(ptr_dst,
                                                            prop_dst,
                                                            opop->subitem_reference_name,
                                                            &item_ptr_ref,
                                                            &item_index_ref))
            {
              is_valid = true;
              item_index_dst = item_index_ref + 1;
            }
          }
          if (!is_valid && opop->subitem_local_index >= 0) {
            /* Find from index. */
            if (RNA_property_collection_lookup_int(
                    ptr_src, prop_src, opop->subitem_local_index, &item_ptr_src) &&
                RNA_property_collection_lookup_int(
                    ptr_dst, prop_dst, opop->subitem_reference_index, &item_ptr_ref))
            {
              item_index_dst = opop->subitem_reference_index + 1;
              is_valid = true;
            }
          }
          if (!is_valid) {
            /* Assume it is inserted in first position. */
            if (RNA_property_collection_lookup_int(ptr_src, prop_src, 0, &item_ptr_src)) {
              item_index_dst = 0;
              is_valid = true;
            }
          }
          if (!is_valid) {
            return false;
          }
 
          RNA_property_collection_add(ptr_dst, prop_dst, &item_ptr_dst);
          const int item_index_added = RNA_property_collection_length(ptr_dst, prop_dst) - 1;
          BLI_assert(item_index_added >= 0);
 
          /* This is the section of code that makes it specific to IDProperties (the rest could be
           * used with some regular RNA/DNA data too, if `RNA_property_collection_add` where
           * actually implemented for those).
           * Currently it is close to impossible to copy arbitrary 'real' RNA data between
           * Collection items. */
          IDProperty *item_idprop_src = static_cast<IDProperty *>(item_ptr_src.data);
          IDProperty *item_idprop_dst = static_cast<IDProperty *>(item_ptr_dst.data);
          IDP_CopyPropertyContent(item_idprop_dst, item_idprop_src);
 
          ret_success = RNA_property_collection_move(
              ptr_dst, prop_dst, item_index_added, item_index_dst);
          break;
        }
        default:
          BLI_assert_msg(0, "Unsupported RNA override operation on collection");
          return false;
      }
      break;
    }
    default:
      BLI_assert_unreachable();
      return false;
  }
 
  /* Default apply callback always call property update. */
  if (ret_success) {
    RNA_property_update_main(bmain, nullptr, ptr_dst, prop_dst);
  }
 
  return ret_success;
}
 
#  undef RNA_PROPERTY_GET_SINGLE
#  undef RNA_PROPERTY_SET_SINGLE
 
/* -------------------------------------------------------------------- */
/* Primitive String. */
 
static void rna_PrimitiveString_value_get(PointerRNA *ptr, char *result)
{
  const PrimitiveStringRNA *data = static_cast<const PrimitiveStringRNA *>(ptr->data);
  strcpy(result, data->value ? data->value : "");
}
 
static int rna_PrimitiveString_value_length(PointerRNA *ptr)
{
  const PrimitiveStringRNA *data = static_cast<const PrimitiveStringRNA *>(ptr->data);
  return data->value ? strlen(data->value) : 0;
}
 
/* Primitive Int. */
 
static int rna_PrimitiveInt_value_get(PointerRNA *ptr)
{
  const PrimitiveIntRNA *data = static_cast<const PrimitiveIntRNA *>(ptr->data);
  return data->value;
}
 
/* Primitive Float. */
 
static float rna_PrimitiveFloat_value_get(PointerRNA *ptr)
{
  const PrimitiveFloatRNA *data = static_cast<const PrimitiveFloatRNA *>(ptr->data);
  return data->value;
}
 
/* Primitive Boolean. */
 
static bool rna_PrimitiveBoolean_value_get(PointerRNA *ptr)
{
  const PrimitiveBooleanRNA *data = static_cast<const PrimitiveBooleanRNA *>(ptr->data);
  return data->value;
}
 
#else
 
static void rna_def_struct(BlenderRNA *brna)
{
  StructRNA *srna;
  PropertyRNA *prop;
 
  srna = RNA_def_struct(brna, "Struct", nullptr);
  RNA_def_struct_ui_text(srna, "Struct Definition", "RNA structure definition");
  RNA_def_struct_ui_icon(srna, ICON_RNA);
 
  prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_string_funcs(prop, "rna_Struct_name_get", "rna_Struct_name_length", nullptr);
  RNA_def_property_ui_text(prop, "Name", "Human readable name");
 
  prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_string_funcs(
      prop, "rna_Struct_identifier_get", "rna_Struct_identifier_length", nullptr);
  RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
  RNA_def_struct_name_property(srna, prop);
 
  prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_string_funcs(
      prop, "rna_Struct_description_get", "rna_Struct_description_length", nullptr);
  RNA_def_property_ui_text(prop, "Description", "Description of the Struct's purpose");
 
  prop = RNA_def_property(srna, "translation_context", PROP_STRING, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_string_funcs(prop,
                                "rna_Struct_translation_context_get",
                                "rna_Struct_translation_context_length",
                                nullptr);
  RNA_def_property_ui_text(
      prop, "Translation Context", "Translation context of the struct's name");
 
  prop = RNA_def_property(srna, "base", PROP_POINTER, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_struct_type(prop, "Struct");
  RNA_def_property_pointer_funcs(prop, "rna_Struct_base_get", nullptr, nullptr, nullptr);
  RNA_def_property_ui_text(prop, "Base", "Struct definition this is derived from");
 
  prop = RNA_def_property(srna, "nested", PROP_POINTER, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_struct_type(prop, "Struct");
  RNA_def_property_pointer_funcs(prop, "rna_Struct_nested_get", nullptr, nullptr, nullptr);
  RNA_def_property_ui_text(
      prop,
      "Nested",
      "Struct in which this struct is always nested, and to which it logically belongs");
 
  prop = RNA_def_property(srna, "name_property", PROP_POINTER, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_struct_type(prop, "StringProperty");
  RNA_def_property_pointer_funcs(prop, "rna_Struct_name_property_get", nullptr, nullptr, nullptr);
  RNA_def_property_ui_text(prop, "Name Property", "Property that gives the name of the struct");
 
  prop = RNA_def_property(srna, "properties", PROP_COLLECTION, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_struct_type(prop, "Property");
  RNA_def_property_collection_funcs(prop,
                                    "rna_Struct_properties_begin",
                                    "rna_Struct_properties_next",
                                    "rna_iterator_listbase_end",
                                    "rna_Struct_properties_get",
                                    nullptr,
                                    nullptr,
                                    nullptr,
                                    nullptr);
  RNA_def_property_ui_text(prop, "Properties", "Properties in the struct");
 
  prop = RNA_def_property(srna, "functions", PROP_COLLECTION, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_struct_type(prop, "Function");
  RNA_def_property_collection_funcs(prop,
                                    "rna_Struct_functions_begin",
                                    "rna_Struct_functions_next",
                                    "rna_iterator_listbase_end",
                                    "rna_Struct_functions_get",
                                    nullptr,
                                    nullptr,
                                    nullptr,
                                    nullptr);
  RNA_def_property_ui_text(prop, "Functions", "");
 
  prop = RNA_def_property(srna, "property_tags", PROP_COLLECTION, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_struct_type(prop, "EnumPropertyItem");
  RNA_def_property_collection_funcs(prop,
                                    "rna_Struct_property_tags_begin",
                                    "rna_iterator_array_next",
                                    "rna_iterator_array_end",
                                    "rna_iterator_array_get",
                                    nullptr,
                                    nullptr,
                                    nullptr,
                                    nullptr);
  RNA_def_property_ui_text(
      prop, "Property Tags", "Tags that properties can use to influence behavior");
}
 
static void rna_def_property(BlenderRNA *brna)
{
  StructRNA *srna;
  PropertyRNA *prop;
  static const EnumPropertyItem dummy_prop_tags[] = {
      {0, nullptr, 0, nullptr, nullptr},
  };
 
  srna = RNA_def_struct(brna, "Property", nullptr);
  RNA_def_struct_ui_text(srna, "Property Definition", "RNA property definition");
  RNA_def_struct_refine_func(srna, "rna_Property_refine");
  RNA_def_struct_ui_icon(srna, ICON_RNA);
 
  prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_string_funcs(
      prop, "rna_Property_name_get", "rna_Property_name_length", nullptr);
  RNA_def_property_ui_text(prop, "Name", "Human readable name");
 
  prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_string_funcs(
      prop, "rna_Property_identifier_get", "rna_Property_identifier_length", nullptr);
  RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
  RNA_def_struct_name_property(srna, prop);
 
  prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_string_funcs(
      prop, "rna_Property_description_get", "rna_Property_description_length", nullptr);
  RNA_def_property_ui_text(prop, "Description", "Description of the property for tooltips");
 
  prop = RNA_def_property(srna, "translation_context", PROP_STRING, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_string_funcs(prop,
                                "rna_Property_translation_context_get",
                                "rna_Property_translation_context_length",
                                nullptr);
  RNA_def_property_ui_text(
      prop, "Translation Context", "Translation context of the property's name");
 
  prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_enum_items(prop, rna_enum_property_type_items);
  RNA_def_property_enum_funcs(prop, "rna_Property_type_get", nullptr, nullptr);
  RNA_def_property_ui_text(prop, "Type", "Data type of the property");
 
  prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_enum_items(prop, rna_enum_property_subtype_items);
  RNA_def_property_enum_funcs(prop, "rna_Property_subtype_get", nullptr, nullptr);
  RNA_def_property_ui_text(prop, "Subtype", "Semantic interpretation of the property");
 
  prop = RNA_def_property(srna, "srna", PROP_POINTER, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_struct_type(prop, "Struct");
  RNA_def_property_pointer_funcs(prop, "rna_Property_srna_get", nullptr, nullptr, nullptr);
  RNA_def_property_ui_text(
      prop, "Base", "Struct definition used for properties assigned to this item");
 
  prop = RNA_def_property(srna, "unit", PROP_ENUM, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_enum_items(prop, rna_enum_property_unit_items);
  RNA_def_property_enum_funcs(prop, "rna_Property_unit_get", nullptr, nullptr);
  RNA_def_property_ui_text(prop, "Unit", "Type of units for this property");
 
  prop = RNA_def_property(srna, "icon", PROP_ENUM, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_enum_items(prop, rna_enum_icon_items);
  RNA_def_property_enum_funcs(prop, "rna_Property_icon_get", nullptr, nullptr);
  RNA_def_property_ui_text(prop, "Icon", "Icon of the item");
 
  prop = RNA_def_property(srna, "is_readonly", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Property_readonly_get", nullptr);
  RNA_def_property_ui_text(prop, "Read Only", "Property is editable through RNA");
 
  prop = RNA_def_property(srna, "is_animatable", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Property_animatable_get", nullptr);
  RNA_def_property_ui_text(prop, "Animatable", "Property is animatable through RNA");
 
  prop = RNA_def_property(srna, "is_overridable", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Property_overridable_get", nullptr);
  RNA_def_property_ui_text(prop, "Overridable", "Property is overridable through RNA");
 
  prop = RNA_def_property(srna, "is_required", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Property_is_required_get", nullptr);
  RNA_def_property_ui_text(
      prop, "Required", "False when this property is an optional argument in an RNA function");
 
  prop = RNA_def_property(srna, "is_argument_optional", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Property_is_argument_optional_get", nullptr);
  RNA_def_property_ui_text(
      prop,
      "Optional Argument",
      "True when the property is optional in a Python function implementing an RNA function");
 
  prop = RNA_def_property(srna, "is_never_none", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Property_is_never_none_get", nullptr);
  RNA_def_property_ui_text(prop, "Never None", "True when this value can't be set to None");
 
  prop = RNA_def_property(srna, "is_hidden", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Property_is_hidden_get", nullptr);
  RNA_def_property_ui_text(prop, "Hidden", "True when the property is hidden");
 
  prop = RNA_def_property(srna, "is_skip_save", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Property_is_skip_save_get", nullptr);
  RNA_def_property_ui_text(prop, "Skip Save", "True when the property uses ghost values");
 
  prop = RNA_def_property(srna, "is_skip_preset", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Property_is_skip_preset_get", nullptr);
  RNA_def_property_ui_text(prop, "Skip Preset", "True when the property is not saved in presets");
 
  prop = RNA_def_property(srna, "is_output", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Property_use_output_get", nullptr);
  RNA_def_property_ui_text(
      prop, "Return", "True when this property is an output value from an RNA function");
 
  prop = RNA_def_property(srna, "is_registered", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Property_is_registered_get", nullptr);
  RNA_def_property_ui_text(
      prop, "Registered", "Property is registered as part of type registration");
 
  prop = RNA_def_property(srna, "is_registered_optional", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Property_is_registered_optional_get", nullptr);
  RNA_def_property_ui_text(prop,
                           "Registered Optionally",
                           "Property is optionally registered as part of type registration");
 
  prop = RNA_def_property(srna, "is_runtime", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Property_is_runtime_get", nullptr);
  RNA_def_property_ui_text(prop, "Runtime", "Property has been dynamically created at runtime");
 
  prop = RNA_def_property(srna, "is_enum_flag", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Property_is_enum_flag_get", nullptr);
  RNA_def_property_ui_text(prop, "Enum Flag", "True when multiple enums");
 
  prop = RNA_def_property(srna, "is_library_editable", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Property_is_library_editable_flag_get", nullptr);
  RNA_def_property_ui_text(
      prop, "Library Editable", "Property is editable from linked instances (changes not saved)");
 
  prop = RNA_def_property(srna, "is_path_output", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Property_is_path_output_flag_get", nullptr);
  RNA_def_property_ui_text(
      prop, "Path Output", "Property is a filename, filepath or directory output");
 
  prop = RNA_def_property(srna, "tags", PROP_ENUM, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_enum_items(prop, dummy_prop_tags);
  RNA_def_property_enum_funcs(prop, "rna_Property_tags_get", nullptr, "rna_Property_tags_itemf");
  RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL | PROP_ENUM_FLAG);
  RNA_def_property_ui_text(
      prop, "Tags", "Subset of tags (defined in parent struct) that are set for this property");
}
 
static void rna_def_function(BlenderRNA *brna)
{
  StructRNA *srna;
  PropertyRNA *prop;
 
  srna = RNA_def_struct(brna, "Function", nullptr);
  RNA_def_struct_ui_text(srna, "Function Definition", "RNA function definition");
  RNA_def_struct_ui_icon(srna, ICON_RNA);
 
  prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_string_funcs(
      prop, "rna_Function_identifier_get", "rna_Function_identifier_length", nullptr);
  RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
  RNA_def_struct_name_property(srna, prop);
 
  prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_string_funcs(
      prop, "rna_Function_description_get", "rna_Function_description_length", nullptr);
  RNA_def_property_ui_text(prop, "Description", "Description of the Function's purpose");
 
  prop = RNA_def_property(srna, "parameters", PROP_COLLECTION, PROP_NONE);
  // RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_struct_type(prop, "Property");
  RNA_def_property_collection_funcs(prop,
                                    "rna_Function_parameters_begin",
                                    "rna_iterator_listbase_next",
                                    "rna_iterator_listbase_end",
                                    "rna_iterator_listbase_get",
                                    nullptr,
                                    nullptr,
                                    nullptr,
                                    nullptr);
  RNA_def_property_ui_text(prop, "Parameters", "Parameters for the function");
 
  prop = RNA_def_property(srna, "is_registered", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Function_registered_get", nullptr);
  RNA_def_property_ui_text(
      prop, "Registered", "Function is registered as callback as part of type registration");
 
  prop = RNA_def_property(srna, "is_registered_optional", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Function_registered_optional_get", nullptr);
  RNA_def_property_ui_text(
      prop,
      "Registered Optionally",
      "Function is optionally registered as callback part of type registration");
 
  prop = RNA_def_property(srna, "use_self", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Function_no_self_get", nullptr);
  RNA_def_property_ui_text(
      prop,
      "No Self",
      "Function does not pass itself as an argument (becomes a static method in Python)");
 
  prop = RNA_def_property(srna, "use_self_type", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_Function_use_self_type_get", nullptr);
  RNA_def_property_ui_text(prop,
                           "Use Self Type",
                           "Function passes itself type as an argument (becomes a class method "
                           "in Python if use_self is false)");
}
 
static void rna_def_number_property(StructRNA *srna, PropertyType type)
{
  PropertyRNA *prop;
 
  prop = RNA_def_property(srna, "default", type, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_ui_text(prop, "Default", "Default value for this number");
 
  switch (type) {
    case PROP_BOOLEAN:
      RNA_def_property_boolean_funcs(prop, "rna_BoolProperty_default_get", nullptr);
      break;
    case PROP_INT:
      RNA_def_property_int_funcs(prop, "rna_IntProperty_default_get", nullptr, nullptr);
      break;
    case PROP_FLOAT:
      RNA_def_property_float_funcs(prop, "rna_FloatProperty_default_get", nullptr, nullptr);
      break;
    default:
      break;
  }
 
  prop = RNA_def_property(srna, "default_array", type, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 
  /* no fixed default length, important its not 0 though. */
  RNA_def_property_array(prop, RNA_MAX_ARRAY_DIMENSION);
 
  RNA_def_property_flag(prop, PROP_DYNAMIC);
  RNA_def_property_dynamic_array_funcs(
      prop, "rna_NumberProperty_default_array_get_length"); /* same for all types */
 
  switch (type) {
    case PROP_BOOLEAN:
      RNA_def_property_boolean_funcs(prop, "rna_BoolProperty_default_array_get", nullptr);
      break;
    case PROP_INT:
      RNA_def_property_int_funcs(prop, "rna_IntProperty_default_array_get", nullptr, nullptr);
      break;
    case PROP_FLOAT:
      RNA_def_property_float_funcs(prop, "rna_FloatProperty_default_array_get", nullptr, nullptr);
      break;
    default:
      break;
  }
  RNA_def_property_ui_text(prop, "Default Array", "Default value for this array");
 
  prop = RNA_def_property(srna, "array_length", PROP_INT, PROP_UNSIGNED);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_int_funcs(prop, "rna_Property_array_length_get", nullptr, nullptr);
  RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited");
 
  prop = RNA_def_property(srna, "array_dimensions", PROP_INT, PROP_UNSIGNED);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_array(prop, RNA_MAX_ARRAY_DIMENSION);
  RNA_def_property_int_funcs(prop, "rna_Property_array_dimensions_get", nullptr, nullptr);
  RNA_def_property_ui_text(prop, "Array Dimensions", "Length of each dimension of the array");
 
  prop = RNA_def_property(srna, "is_array", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_NumberProperty_is_array_get", nullptr);
  RNA_def_property_ui_text(prop, "Is Array", "");
 
  if (type == PROP_BOOLEAN) {
    return;
  }
 
  prop = RNA_def_property(srna, "hard_min", type, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  if (type == PROP_INT) {
    RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_min_get", nullptr, nullptr);
  }
  else {
    RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_min_get", nullptr, nullptr);
  }
  RNA_def_property_ui_text(prop, "Hard Minimum", "Minimum value used by buttons");
 
  prop = RNA_def_property(srna, "hard_max", type, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  if (type == PROP_INT) {
    RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_max_get", nullptr, nullptr);
  }
  else {
    RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_max_get", nullptr, nullptr);
  }
  RNA_def_property_ui_text(prop, "Hard Maximum", "Maximum value used by buttons");
 
  prop = RNA_def_property(srna, "soft_min", type, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  if (type == PROP_INT) {
    RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_min_get", nullptr, nullptr);
  }
  else {
    RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_min_get", nullptr, nullptr);
  }
  RNA_def_property_ui_text(prop, "Soft Minimum", "Minimum value used by buttons");
 
  prop = RNA_def_property(srna, "soft_max", type, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  if (type == PROP_INT) {
    RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_max_get", nullptr, nullptr);
  }
  else {
    RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_max_get", nullptr, nullptr);
  }
  RNA_def_property_ui_text(prop, "Soft Maximum", "Maximum value used by buttons");
 
  prop = RNA_def_property(srna, "step", type, PROP_UNSIGNED);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  if (type == PROP_INT) {
    RNA_def_property_int_funcs(prop, "rna_IntProperty_step_get", nullptr, nullptr);
  }
  else {
    RNA_def_property_float_funcs(prop, "rna_FloatProperty_step_get", nullptr, nullptr);
  }
  RNA_def_property_ui_text(
      prop, "Step", "Step size used by number buttons, for floats 1/100th of the step size");
 
  if (type == PROP_FLOAT) {
    prop = RNA_def_property(srna, "precision", PROP_INT, PROP_UNSIGNED);
    RNA_def_property_clear_flag(prop, PROP_EDITABLE);
    RNA_def_property_int_funcs(prop, "rna_FloatProperty_precision_get", nullptr, nullptr);
    RNA_def_property_ui_text(prop,
                             "Precision",
                             "Number of digits after the dot used by buttons. Fraction is "
                             "automatically hidden for exact integer values of fields with unit "
                             "'NONE' or 'TIME' (frame count) and step divisible by 100.");
  }
}
 
static void rna_def_string_property(StructRNA *srna)
{
  PropertyRNA *prop;
 
  prop = RNA_def_property(srna, "default", PROP_STRING, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_string_funcs(
      prop, "rna_StringProperty_default_get", "rna_StringProperty_default_length", nullptr);
  RNA_def_property_ui_text(prop, "Default", "String default value");
 
  prop = RNA_def_property(srna, "length_max", PROP_INT, PROP_UNSIGNED);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_int_funcs(prop, "rna_StringProperty_max_length_get", nullptr, nullptr);
  RNA_def_property_ui_text(
      prop, "Maximum Length", "Maximum length of the string, 0 means unlimited");
}
 
static void rna_def_enum_property(BlenderRNA *brna, StructRNA *srna)
{
  PropertyRNA *prop;
 
  /* the itemf func is used instead, keep blender happy */
  static const EnumPropertyItem default_dummy_items[] = {
      {PROP_NONE, "DUMMY", 0, "Dummy", ""},
      {0, nullptr, 0, nullptr, nullptr},
  };
 
  prop = RNA_def_property(srna, "default", PROP_ENUM, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_enum_items(prop, default_dummy_items);
  RNA_def_property_enum_funcs(
      prop, "rna_EnumProperty_default_get", nullptr, "rna_EnumProperty_default_itemf");
  RNA_def_property_ui_text(prop, "Default", "Default value for this enum");
 
  /* same 'default' but uses 'PROP_ENUM_FLAG' */
  prop = RNA_def_property(srna, "default_flag", PROP_ENUM, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_flag(prop, PROP_ENUM_FLAG);
  RNA_def_property_enum_items(prop, default_dummy_items);
  RNA_def_property_enum_funcs(
      prop, "rna_EnumProperty_default_get", nullptr, "rna_EnumProperty_default_itemf");
  RNA_def_property_ui_text(prop, "Default", "Default value for this enum");
 
  prop = RNA_def_property(srna, "enum_items", PROP_COLLECTION, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_struct_type(prop, "EnumPropertyItem");
  RNA_def_property_collection_funcs(prop,
                                    "rna_EnumProperty_items_begin",
                                    "rna_iterator_array_next",
                                    "rna_iterator_array_end",
                                    "rna_iterator_array_get",
                                    nullptr,
                                    nullptr,
                                    nullptr,
                                    nullptr);
  RNA_def_property_ui_text(prop, "Items", "Possible values for the property");
 
  prop = RNA_def_property(srna, "enum_items_static", PROP_COLLECTION, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_struct_type(prop, "EnumPropertyItem");
  RNA_def_property_collection_funcs(prop,
                                    "rna_EnumProperty_items_begin",
                                    "rna_iterator_array_next",
                                    "rna_iterator_array_end",
                                    "rna_iterator_array_get",
                                    nullptr,
                                    nullptr,
                                    nullptr,
                                    nullptr);
  RNA_def_property_ui_text(
      prop,
      "Static Items",
      "Possible values for the property (never calls optional dynamic generation of those)");
 
  /* Expose a UI version of `enum_items_static` to allow separator & title access,
   * needed for the tool-system to access separators from brush enums. */
  prop = RNA_def_property(srna, "enum_items_static_ui", PROP_COLLECTION, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_struct_type(prop, "EnumPropertyItem");
  RNA_def_property_collection_funcs(prop,
                                    "rna_EnumProperty_items_ui_begin",
                                    "rna_iterator_array_next",
                                    "rna_iterator_array_end",
                                    "rna_iterator_array_get",
                                    nullptr,
                                    nullptr,
                                    nullptr,
                                    nullptr);
  RNA_def_property_ui_text(
      prop,
      "Static Items with UI Elements",
      "Possible values for the property (never calls optional dynamic generation of those). "
      "Includes UI elements (separators and section headings).");
 
  srna = RNA_def_struct(brna, "EnumPropertyItem", nullptr);
  RNA_def_struct_ui_text(
      srna, "Enum Item Definition", "Definition of a choice in an RNA enum property");
  RNA_def_struct_ui_icon(srna, ICON_RNA);
 
  prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_string_funcs(
      prop, "rna_EnumPropertyItem_name_get", "rna_EnumPropertyItem_name_length", nullptr);
  RNA_def_property_ui_text(prop, "Name", "Human readable name");
 
  prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_string_funcs(prop,
                                "rna_EnumPropertyItem_description_get",
                                "rna_EnumPropertyItem_description_length",
                                nullptr);
  RNA_def_property_ui_text(prop, "Description", "Description of the item's purpose");
 
  prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_string_funcs(prop,
                                "rna_EnumPropertyItem_identifier_get",
                                "rna_EnumPropertyItem_identifier_length",
                                nullptr);
  RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
  RNA_def_struct_name_property(srna, prop);
 
  prop = RNA_def_property(srna, "value", PROP_INT, PROP_UNSIGNED);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_int_funcs(prop, "rna_EnumPropertyItem_value_get", nullptr, nullptr);
  RNA_def_property_ui_text(prop, "Value", "Value of the item");
 
  prop = RNA_def_property(srna, "icon", PROP_ENUM, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_enum_items(prop, rna_enum_icon_items);
  RNA_def_property_enum_funcs(prop, "rna_EnumPropertyItem_icon_get", nullptr, nullptr);
  RNA_def_property_ui_text(prop, "Icon", "Icon of the item");
}
 
static void rna_def_pointer_property(StructRNA *srna, PropertyType type)
{
  PropertyRNA *prop;
 
  prop = RNA_def_property(srna, "fixed_type", PROP_POINTER, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_struct_type(prop, "Struct");
  if (type == PROP_POINTER) {
    RNA_def_property_pointer_funcs(
        prop, "rna_PointerProperty_fixed_type_get", nullptr, nullptr, nullptr);
  }
  else {
    RNA_def_property_pointer_funcs(
        prop, "rna_CollectionProperty_fixed_type_get", nullptr, nullptr, nullptr);
  }
  RNA_def_property_ui_text(prop, "Pointer Type", "Fixed pointer type, empty if variable type");
}
 
static void rna_def_rna_primitive(BlenderRNA *brna)
{
  /* Primitive Values, use when passing #PointerRNA is used for primitive types.
   * For the rare cases we want to pass a value as RNA which wraps a primitive data. */
 
  StructRNA *srna;
  PropertyRNA *prop;
 
  srna = RNA_def_struct(brna, "PrimitiveString", nullptr);
  RNA_def_struct_ui_text(srna, "String Value", "RNA wrapped string");
  prop = RNA_def_property(srna, "value", PROP_STRING, PROP_BYTESTRING);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_string_funcs(
      prop, "rna_PrimitiveString_value_get", "rna_PrimitiveString_value_length", nullptr);
 
  srna = RNA_def_struct(brna, "PrimitiveInt", nullptr);
  RNA_def_struct_ui_text(srna, "Primitive Int", "RNA wrapped int");
  prop = RNA_def_property(srna, "value", PROP_INT, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_int_funcs(prop, "rna_PrimitiveInt_value_get", nullptr, nullptr);
 
  srna = RNA_def_struct(brna, "PrimitiveFloat", nullptr);
  RNA_def_struct_ui_text(srna, "Primitive Float", "RNA wrapped float");
  prop = RNA_def_property(srna, "value", PROP_FLOAT, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_float_funcs(prop, "rna_PrimitiveFloat_value_get", nullptr, nullptr);
 
  srna = RNA_def_struct(brna, "PrimitiveBoolean", nullptr);
  RNA_def_struct_ui_text(srna, "Primitive Boolean", "RNA wrapped boolean");
  prop = RNA_def_property(srna, "value", PROP_BOOLEAN, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_boolean_funcs(prop, "rna_PrimitiveBoolean_value_get", nullptr);
}
 
void RNA_def_rna(BlenderRNA *brna)
{
  StructRNA *srna;
  PropertyRNA *prop;
 
  /* Struct */
  rna_def_struct(brna);
 
  /* Property */
  rna_def_property(brna);
 
  /* BoolProperty */
  srna = RNA_def_struct(brna, "BoolProperty", "Property");
  RNA_def_struct_ui_text(srna, "Boolean Definition", "RNA boolean property definition");
  rna_def_number_property(srna, PROP_BOOLEAN);
 
  /* IntProperty */
  srna = RNA_def_struct(brna, "IntProperty", "Property");
  RNA_def_struct_ui_text(srna, "Int Definition", "RNA integer number property definition");
  rna_def_number_property(srna, PROP_INT);
 
  /* FloatProperty */
  srna = RNA_def_struct(brna, "FloatProperty", "Property");
  RNA_def_struct_ui_text(srna,
                         "Float Definition",
                         "RNA floating-point number (single precision) property definition");
  rna_def_number_property(srna, PROP_FLOAT);
 
  /* StringProperty */
  srna = RNA_def_struct(brna, "StringProperty", "Property");
  RNA_def_struct_ui_text(srna, "String Definition", "RNA text string property definition");
  rna_def_string_property(srna);
 
  /* EnumProperty */
  srna = RNA_def_struct(brna, "EnumProperty", "Property");
  RNA_def_struct_ui_text(
      srna,
      "Enum Definition",
      "RNA enumeration property definition, to choose from a number of predefined options");
  rna_def_enum_property(brna, srna);
 
  /* PointerProperty */
  srna = RNA_def_struct(brna, "PointerProperty", "Property");
  RNA_def_struct_ui_text(
      srna, "Pointer Definition", "RNA pointer property to point to another RNA struct");
  rna_def_pointer_property(srna, PROP_POINTER);
 
  /* CollectionProperty */
  srna = RNA_def_struct(brna, "CollectionProperty", "Property");
  RNA_def_struct_ui_text(srna,
                         "Collection Definition",
                         "RNA collection property to define lists, arrays and mappings");
  rna_def_pointer_property(srna, PROP_COLLECTION);
 
  /* Function */
  rna_def_function(brna);
 
  /* Blender RNA */
  srna = RNA_def_struct(brna, "BlenderRNA", nullptr);
  RNA_def_struct_ui_text(srna, "Blender RNA", "Blender RNA structure definitions");
  RNA_def_struct_ui_icon(srna, ICON_RNA);
 
  prop = RNA_def_property(srna, "structs", PROP_COLLECTION, PROP_NONE);
  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  RNA_def_property_struct_type(prop, "Struct");
  RNA_def_property_collection_funcs(prop,
                                    "rna_BlenderRNA_structs_begin",
                                    "rna_iterator_listbase_next",
                                    "rna_iterator_listbase_end",
                                    "rna_iterator_listbase_get",
/* included for speed, can be removed */
#  if 0
                                    nullptr,
                                    nullptr,
                                    nullptr,
                                    nullptr);
#  else
                                    "rna_BlenderRNA_structs_length",
                                    "rna_BlenderRNA_structs_lookup_int",
                                    "rna_BlenderRNA_structs_lookup_string",
                                    nullptr);
#  endif
 
  RNA_def_property_ui_text(prop, "Structs", "");
 
  rna_def_rna_primitive(brna);
}
 
#endif