rna_internal_types.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include <optional>
#include <string>
 
#include "BLI_vector_set.hh"
 
#include "DNA_listBase.h"
 
#include "RNA_access.hh"
#include "RNA_define.hh"
#include "RNA_types.hh"
 
struct BlenderRNA;
struct CollectionPropertyIterator;
struct ContainerRNA;
struct FunctionRNA;
struct GHash;
struct IDOverrideLibrary;
struct IDOverrideLibraryPropertyOperation;
struct IDProperty;
struct Main;
struct PointerRNA;
struct PropertyRNA;
struct ReportList;
struct Scene;
struct StructRNA;
struct bContext;
 
/* Function Callbacks */

using UpdateFunc = void (*)(Main *bmain, Scene *active_scene, PointerRNA *ptr);
using ContextPropUpdateFunc = void (*)(bContext *C, PointerRNA *ptr, PropertyRNA *prop);
using ContextUpdateFunc = void (*)(bContext *C, PointerRNA *ptr);
 
using EditableFunc = int (*)(const PointerRNA *ptr, const char **r_info);
using ItemEditableFunc = int (*)(const PointerRNA *ptr, int index);
using IDPropertiesFunc = IDProperty **(*)(PointerRNA * ptr);
using StructRefineFunc = StructRNA *(*)(PointerRNA * ptr);
using StructPathFunc = std::optional<std::string> (*)(const PointerRNA *ptr);
using PropUINameFunc = const char *(*)(const PointerRNA *ptr,
                                       const PropertyRNA *prop,
                                       bool do_translate);
 
using PropArrayLengthGetFunc = int (*)(const PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION]);
using PropBooleanGetFunc = bool (*)(PointerRNA *ptr);
using PropBooleanSetFunc = void (*)(PointerRNA *ptr, bool value);
using PropBooleanArrayGetFunc = void (*)(PointerRNA *ptr, bool *values);
using PropBooleanArraySetFunc = void (*)(PointerRNA *ptr, const bool *values);
using PropIntGetFunc = int (*)(PointerRNA *ptr);
using PropIntSetFunc = void (*)(PointerRNA *ptr, int value);
using PropIntArrayGetFunc = void (*)(PointerRNA *ptr, int *values);
using PropIntArraySetFunc = void (*)(PointerRNA *ptr, const int *values);
using PropIntRangeFunc = void (*)(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax);
using PropFloatGetFunc = float (*)(PointerRNA *ptr);
using PropFloatSetFunc = void (*)(PointerRNA *ptr, float value);
using PropFloatArrayGetFunc = void (*)(PointerRNA *ptr, float *values);
using PropFloatArraySetFunc = void (*)(PointerRNA *ptr, const float *values);
using PropFloatRangeFunc =
    void (*)(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax);
using PropStringGetFunc = void (*)(PointerRNA *ptr, char *value);
using PropStringLengthFunc = int (*)(PointerRNA *ptr);
using PropStringSetFunc = void (*)(PointerRNA *ptr, const char *value);
using PropEnumGetFunc = int (*)(PointerRNA *ptr);
using PropEnumSetFunc = void (*)(PointerRNA *ptr, int value);
using PropEnumItemFunc = const EnumPropertyItem *(*)(bContext * C,
                                                     PointerRNA *ptr,
                                                     PropertyRNA *prop,
                                                     bool *r_free);
using PropPointerGetFunc = PointerRNA (*)(PointerRNA *ptr);
using PropPointerTypeFunc = StructRNA *(*)(PointerRNA * ptr);
using PropPointerSetFunc = void (*)(PointerRNA *ptr, const PointerRNA value, ReportList *reports);
using PropPointerPollFunc = bool (*)(PointerRNA *ptr, const PointerRNA value);
using PropPointerPollFuncPy = bool (*)(PointerRNA *ptr,
                                       const PointerRNA value,
                                       const PropertyRNA *prop);
using PropCollectionBeginFunc = void (*)(CollectionPropertyIterator *iter, PointerRNA *ptr);
using PropCollectionNextFunc = void (*)(CollectionPropertyIterator *iter);
using PropCollectionEndFunc = void (*)(CollectionPropertyIterator *iter);
using PropCollectionGetFunc = PointerRNA (*)(CollectionPropertyIterator *iter);
using PropCollectionLengthFunc = int (*)(PointerRNA *ptr);
using PropCollectionLookupIntFunc = bool (*)(PointerRNA *ptr, int key, PointerRNA *r_ptr);
using PropCollectionLookupStringFunc = bool (*)(PointerRNA *ptr,
                                                const char *key,
                                                PointerRNA *r_ptr);
using PropCollectionAssignIntFunc = bool (*)(PointerRNA *ptr,
                                             int key,
                                             const PointerRNA *assign_ptr);
 
/* Extended versions with #PropertyRNA argument. */
/* NOTE: All extended get/set callbacks will always get a 'real' PropertyRNA `prop` pointer, never
 * an 'IDProperty as PropertyRNA' one (i.e. when called, the given `prop` is the RNA result of a
 * call to `rna_property_rna_or_id_get` or one of its wrappers). */
 
using PropBooleanGetFuncEx = bool (*)(PointerRNA *ptr, PropertyRNA *prop);
using PropBooleanSetFuncEx = void (*)(PointerRNA *ptr, PropertyRNA *prop, bool value);
using PropBooleanArrayGetFuncEx = void (*)(PointerRNA *ptr, PropertyRNA *prop, bool *values);
using PropBooleanArraySetFuncEx = void (*)(PointerRNA *ptr, PropertyRNA *prop, const bool *values);
using PropIntGetFuncEx = int (*)(PointerRNA *ptr, PropertyRNA *prop);
using PropIntSetFuncEx = void (*)(PointerRNA *ptr, PropertyRNA *prop, int value);
using PropIntArrayGetFuncEx = void (*)(PointerRNA *ptr, PropertyRNA *prop, int *values);
using PropIntArraySetFuncEx = void (*)(PointerRNA *ptr, PropertyRNA *prop, const int *values);
using PropIntRangeFuncEx =
    void (*)(PointerRNA *ptr, PropertyRNA *prop, int *min, int *max, int *softmin, int *softmax);
using PropFloatGetFuncEx = float (*)(PointerRNA *ptr, PropertyRNA *prop);
using PropFloatSetFuncEx = void (*)(PointerRNA *ptr, PropertyRNA *prop, float value);
using PropFloatArrayGetFuncEx = void (*)(PointerRNA *ptr, PropertyRNA *prop, float *values);
using PropFloatArraySetFuncEx = void (*)(PointerRNA *ptr, PropertyRNA *prop, const float *values);
using PropFloatRangeFuncEx = void (*)(
    PointerRNA *ptr, PropertyRNA *prop, float *min, float *max, float *softmin, float *softmax);
using PropStringGetFuncEx = std::string (*)(PointerRNA *ptr, PropertyRNA *prop);
using PropStringLengthFuncEx = int (*)(PointerRNA *ptr, PropertyRNA *prop);
using PropStringSetFuncEx = void (*)(PointerRNA *ptr, PropertyRNA *prop, const std::string &value);
using PropEnumGetFuncEx = int (*)(PointerRNA *ptr, PropertyRNA *prop);
using PropEnumSetFuncEx = void (*)(PointerRNA *ptr, PropertyRNA *prop, int value);
 
/* Transform step (applied after getting, or before setting the value). Currently only used by
 * `bpy`, more details in the documentation of #BPyPropStore. */
/* NOTE: All transform get/set callbacks will always get a 'real' PropertyRNA `prop` pointer, never
 * an 'IDProperty as PropertyRNA' one (i.e. when called, the given `prop` is the RNA result of a
 * call to `rna_property_rna_or_id_get` or one of its wrappers). */
 
using PropBooleanGetTransformFunc = BooleanPropertyGetTransformFunc;
using PropBooleanSetTransformFunc = BooleanPropertySetTransformFunc;
using PropBooleanArrayGetTransformFunc = BooleanArrayPropertyGetTransformFunc;
using PropBooleanArraySetTransformFunc = BooleanArrayPropertySetTransformFunc;
using PropIntGetTransformFunc = IntPropertyGetTransformFunc;
using PropIntSetTransformFunc = IntPropertySetTransformFunc;
using PropIntArrayGetTransformFunc = IntArrayPropertyGetTransformFunc;
using PropIntArraySetTransformFunc = IntArrayPropertySetTransformFunc;
using PropFloatGetTransformFunc = FloatPropertyGetTransformFunc;
using PropFloatSetTransformFunc = FloatPropertySetTransformFunc;
using PropFloatArrayGetTransformFunc = FloatArrayPropertyGetTransformFunc;
using PropFloatArraySetTransformFunc = FloatArrayPropertySetTransformFunc;
using PropStringGetTransformFunc = StringPropertyGetTransformFunc;
using PropStringSetTransformFunc = StringPropertySetTransformFunc;
using PropEnumGetTransformFunc = EnumPropertyGetTransformFunc;
using PropEnumSetTransformFunc = EnumPropertySetTransformFunc;
 
/* Handling override operations, and also comparison. */

struct PropertyRNAOrID {
  PointerRNA *ptr;

  PropertyRNA *rawprop;
  PropertyRNA *rnaprop;
  IDProperty *idprop;
  const char *identifier;

  bool is_idprop;
  bool is_rna_storage_idprop;
  bool is_set;
 
  bool is_array;
  uint array_len;
};

struct RNAPropertyOverrideDiffContext {

  PropertyRNAOrID *prop_a = nullptr;
  PropertyRNAOrID *prop_b = nullptr;
 
  eRNACompareMode mode = RNA_EQ_COMPARE;

  IDOverrideLibrary *liboverride = nullptr;
  const char *rna_path = nullptr;
  size_t rna_path_len = 0;
  eRNAOverrideMatch liboverride_flags = eRNAOverrideMatch(0);


  int comparison = 0;
  eRNAOverrideMatchResult report_flag = eRNAOverrideMatchResult(0);
};
using RNAPropOverrideDiff = void (*)(Main *bmain, RNAPropertyOverrideDiffContext &rnadiff_ctx);

using RNAPropOverrideStore = bool (*)(Main *bmain,
                                      PointerRNA *ptr_local,
                                      PointerRNA *ptr_reference,
                                      PointerRNA *ptr_storage,
                                      PropertyRNA *prop_local,
                                      PropertyRNA *prop_reference,
                                      PropertyRNA *prop_storage,
                                      int len_local,
                                      int len_reference,
                                      int len_storage,
                                      IDOverrideLibraryPropertyOperation *opop);

struct RNAPropertyOverrideApplyContext {
  eRNAOverrideApplyFlag flag = RNA_OVERRIDE_APPLY_FLAG_NOP;
  bool do_insert = false;

  PointerRNA ptr_dst = {};
  PointerRNA ptr_src = {};
  PointerRNA ptr_storage = {};
  PropertyRNA *prop_dst = nullptr;
  PropertyRNA *prop_src = nullptr;
  PropertyRNA *prop_storage = nullptr;

  int len_dst = 0;
  int len_src = 0;
  int len_storage = 0;

  PointerRNA ptr_item_dst = {};
  PointerRNA ptr_item_src = {};
  PointerRNA ptr_item_storage = {};

  IDOverrideLibrary *liboverride = nullptr;
  IDOverrideLibraryProperty *liboverride_property = nullptr;
  IDOverrideLibraryPropertyOperation *liboverride_operation = nullptr;
 
  /* TODO: Add more refined/descriptive result report? */
};
using RNAPropOverrideApply = bool (*)(Main *bmain, RNAPropertyOverrideApplyContext &rnaapply_ctx);
 
struct PropertyRNAIdentifierGetter {
  blender::StringRef operator()(const PropertyRNA *prop) const;
};

struct ContainerRNA {
  void *next, *prev;
 
  blender::CustomIDVectorSet<PropertyRNA *, PropertyRNAIdentifierGetter> *prop_lookup_set;
  ListBase properties;
};
 
struct FunctionRNA {
  ContainerRNA cont;
  const char *identifier;

  int flag;

  const char *description;

  CallFunc call;

  PropertyRNA *c_ret;
};
 
struct PropertyRNA {
  PropertyRNA *next, *prev;

  int magic;

  const char *identifier;
  int flag;
  int flag_override;
  short flag_parameter;
  short flag_internal;
  short tags;

  PropertyPathTemplateType path_template_type;

  const char *name;
  const char *description;
  int icon;
  const char *translation_context;

  const DeprecatedRNA *deprecated;

  PropertyType type;
  PropertySubType subtype;
  PropArrayLengthGetFunc getlength;
  unsigned int arraydimension;
  unsigned int arraylength[RNA_MAX_ARRAY_DIMENSION];
  unsigned int totarraylength;

  UpdateFunc update;
  int noteflag;

  EditableFunc editable;
  ItemEditableFunc itemeditable;

  PropUINameFunc ui_name_func;

  RNAPropOverrideDiff override_diff;
  RNAPropOverrideStore override_store;
  RNAPropOverrideApply override_apply;
 
  /* Raw access. */
 
  int rawoffset;
  RawPropertyType rawtype;

  StructRNA *srna;

  void *py_data;
};
 
inline blender::StringRef PropertyRNAIdentifierGetter::operator()(const PropertyRNA *prop) const
{
  return prop->identifier;
}

enum PropertyFlagIntern {
  PROP_INTERN_BUILTIN = (1 << 0),
  PROP_INTERN_RUNTIME = (1 << 1),
  PROP_INTERN_RAW_ACCESS = (1 << 2),
  PROP_INTERN_RAW_ARRAY = (1 << 3),
  PROP_INTERN_FREE_POINTERS = (1 << 4),
  PROP_INTERN_PTR_OWNERSHIP_FORCED = (1 << 5),
  PROP_INTERN_PTR_ID_REFCOUNT_FORCED = (1 << 6),
};
 
/* Property Types. */
 
struct BoolPropertyRNA {
  PropertyRNA property;
 
  PropBooleanGetFunc get;
  PropBooleanSetFunc set;
  PropBooleanArrayGetFunc getarray;
  PropBooleanArraySetFunc setarray;
 
  PropBooleanGetFuncEx get_ex;
  PropBooleanSetFuncEx set_ex;
  PropBooleanArrayGetFuncEx getarray_ex;
  PropBooleanArraySetFuncEx setarray_ex;
 
  PropBooleanGetTransformFunc get_transform;
  PropBooleanSetTransformFunc set_transform;
  PropBooleanArrayGetTransformFunc getarray_transform;
  PropBooleanArraySetTransformFunc setarray_transform;
 
  PropBooleanGetFuncEx get_default;
  PropBooleanArrayGetFuncEx get_default_array;
  bool defaultvalue;
  const bool *defaultarray;
};
 
struct IntPropertyRNA {
  PropertyRNA property;
 
  PropIntGetFunc get;
  PropIntSetFunc set;
  PropIntArrayGetFunc getarray;
  PropIntArraySetFunc setarray;
  PropIntRangeFunc range;
 
  PropIntGetFuncEx get_ex;
  PropIntSetFuncEx set_ex;
  PropIntArrayGetFuncEx getarray_ex;
  PropIntArraySetFuncEx setarray_ex;
  PropIntRangeFuncEx range_ex;
 
  PropIntGetTransformFunc get_transform;
  PropIntSetTransformFunc set_transform;
  PropIntArrayGetTransformFunc getarray_transform;
  PropIntArraySetTransformFunc setarray_transform;
 
  PropertyScaleType ui_scale_type;
  int softmin, softmax;
  int hardmin, hardmax;
  int step;
 
  PropIntGetFuncEx get_default;
  PropIntArrayGetFuncEx get_default_array;
  int defaultvalue;
  const int *defaultarray;
};
 
struct FloatPropertyRNA {
  PropertyRNA property;
 
  PropFloatGetFunc get;
  PropFloatSetFunc set;
  PropFloatArrayGetFunc getarray;
  PropFloatArraySetFunc setarray;
  PropFloatRangeFunc range;
 
  PropFloatGetFuncEx get_ex;
  PropFloatSetFuncEx set_ex;
  PropFloatArrayGetFuncEx getarray_ex;
  PropFloatArraySetFuncEx setarray_ex;
  PropFloatRangeFuncEx range_ex;
 
  PropFloatGetTransformFunc get_transform;
  PropFloatSetTransformFunc set_transform;
  PropFloatArrayGetTransformFunc getarray_transform;
  PropFloatArraySetTransformFunc setarray_transform;
 
  PropertyScaleType ui_scale_type;
  float softmin, softmax;
  float hardmin, hardmax;
  float step;
  int precision;
 
  PropFloatGetFuncEx get_default;
  PropFloatArrayGetFuncEx get_default_array;
 
  float defaultvalue;
  const float *defaultarray;
};
 
struct StringPropertyRNA {
  PropertyRNA property;
 
  PropStringGetFunc get;
  PropStringLengthFunc length;
  PropStringSetFunc set;
 
  PropStringGetFuncEx get_ex;
  /* This callback only returns the 'storage' length (i.e. length of string returned by `get_ex`),
   * _not_ the final length (potentially modified by the `get_transform` callback). */
  PropStringLengthFuncEx length_ex;
  PropStringSetFuncEx set_ex;
 
  PropStringGetTransformFunc get_transform;
  PropStringSetTransformFunc set_transform;

  StringPropertySearchFunc search;
  eStringPropertySearchFlag search_flag;

  StringPropertyPathFilterFunc path_filter;

  int maxlength;
 
  const char *defaultvalue;
};
 
struct EnumPropertyRNA {
  PropertyRNA property;
 
  PropEnumGetFunc get;
  PropEnumSetFunc set;
  PropEnumItemFunc item_fn;
 
  PropEnumGetFuncEx get_ex;
  PropEnumSetFuncEx set_ex;
 
  PropEnumGetTransformFunc get_transform;
  PropEnumSetTransformFunc set_transform;
 
  PropEnumGetFuncEx get_default;
 
  const EnumPropertyItem *item;
  int totitem;
 
  int defaultvalue;
  const char *native_enum_type;
};
 
struct PointerPropertyRNA {
  PropertyRNA property;
 
  PropPointerGetFunc get;
  PropPointerSetFunc set;
  PropPointerTypeFunc type_fn;
  PropPointerPollFunc poll;
 
  StructRNA *type;
};
 
struct CollectionPropertyRNA {
  PropertyRNA property;
 
  PropCollectionBeginFunc begin;
  PropCollectionNextFunc next;
  PropCollectionEndFunc end; /* optional */
  PropCollectionGetFunc get;
  PropCollectionLengthFunc length;             /* optional */
  PropCollectionLookupIntFunc lookupint;       /* optional */
  PropCollectionLookupStringFunc lookupstring; /* optional */
  PropCollectionAssignIntFunc assignint;       /* optional */

  StructRNA *item_type;
};

struct StructRNA {
  ContainerRNA cont;
  const char *identifier;

  void *py_type;
  void *blender_type;

  int flag;
  const EnumPropertyItem *prop_tag_defines;

  const char *name;
  const char *description;
  const char *translation_context;
  int icon;

  PropertyRNA *nameproperty;

  PropertyRNA *iteratorproperty;

  StructRNA *base;

  StructRNA *nested;

  StructRefineFunc refine;

  StructPathFunc path;

  StructRegisterFunc reg;
  StructUnregisterFunc unreg;
  StructInstanceFunc instance;

  IDPropertiesFunc idproperties;

  IDPropertiesFunc system_idproperties;

  ListBase functions;
};

struct BlenderRNA {
  ListBase structs;
  GHash *structs_map;
  unsigned int structs_len;
};
 
#define CONTAINER_RNA_ID(cont) (*(const char **)(((ContainerRNA *)(cont)) + 1))