BKE_customdata.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2006 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "BLI_cpp_type.hh"
#include "BLI_implicit_sharing.h"
#include "BLI_memory_counter_fwd.hh"
#include "BLI_set.hh"
#include "BLI_span.hh"
#include "BLI_string_ref.hh"
#include "BLI_sys_types.h"
#include "BLI_utildefines.h"
#include "BLI_vector.hh"
 
#include "BKE_volume_enums.hh"
 
#include "DNA_customdata_types.h"
 
struct BlendDataReader;
struct BlendWriter;
struct BMesh;
struct CustomData_MeshMasks;
struct CustomData;
struct CustomDataTransferLayerMap;
struct ID;
struct MeshPairRemap;
 
/* These names are used as prefixes for UV layer names to find the associated boolean
 * layers. They should never be longer than 2 chars, as #MAX_CUSTOMDATA_LAYER_NAME
 * has 4 extra bytes above what can be used for the base layer name, and these
 * prefixes are placed between 2 '.'s at the start of the layer name.
 * For example The uv vert selection layer of a layer named `UVMap.001`
 * will be called `.vs.UVMap.001`. */
#define UV_VERTSEL_NAME "vs"
#define UV_EDGESEL_NAME "es"
#define UV_PINNED_NAME "pn"
 
struct BMUVOffsets {
  int uv;
  int select_vert;
  int select_edge;
  int pin;
};
 
/* A data type large enough to hold 1 element from any custom-data layer type. */
struct CDBlockBytes {
  unsigned char data[64];
};
 
extern const CustomData_MeshMasks CD_MASK_BAREMESH;
extern const CustomData_MeshMasks CD_MASK_BAREMESH_ORIGINDEX;
extern const CustomData_MeshMasks CD_MASK_MESH;
extern const CustomData_MeshMasks CD_MASK_DERIVEDMESH;
extern const CustomData_MeshMasks CD_MASK_BMESH;
extern const CustomData_MeshMasks CD_MASK_EVERYTHING;
 
/* for ORIGINDEX layer type, indicates no original index for this element */
#define ORIGINDEX_NONE -1
 
/* initializes a CustomData object with the same layer setup as source and
 * memory space for totelem elements. mask must be an array of length
 * CD_NUMTYPES elements, that indicate if a layer can be copied. */
 
enum eCDAllocType {
  CD_SET_DEFAULT = 2,
  CD_CONSTRUCT = 5,
};
 
#define CD_TYPE_AS_MASK(_type) (eCustomDataMask)((eCustomDataMask)1 << (eCustomDataMask)(_type))
 
void customData_mask_layers__print(const CustomData_MeshMasks *mask);
 
using cd_interp = void (*)(
    const void **sources, const float *weights, const float *sub_weights, int count, void *dest);
using cd_copy = void (*)(const void *source, void *dest, int count);
using cd_set_default_value = void (*)(void *data, int count);
using cd_free = void (*)(void *data, int count);
using cd_validate = bool (*)(void *item, uint totitems, bool do_fixes);
 
void CustomData_MeshMasks_update(CustomData_MeshMasks *mask_dst,
                                 const CustomData_MeshMasks *mask_src);
bool CustomData_MeshMasks_are_matching(const CustomData_MeshMasks *mask_ref,
                                       const CustomData_MeshMasks *mask_required);
 
bool CustomData_layer_has_math(const CustomData *data, int layer_n);
bool CustomData_layer_has_interp(const CustomData *data, int layer_n);
 
bool CustomData_has_math(const CustomData *data);
bool CustomData_has_interp(const CustomData *data);
bool CustomData_bmesh_has_free(const CustomData *data);
 
bool CustomData_has_referenced(const CustomData *data);
 
void CustomData_data_copy_value(eCustomDataType type, const void *source, void *dest);
void CustomData_data_set_default_value(eCustomDataType type, void *elem);
 
void CustomData_data_mix_value(
    eCustomDataType type, const void *source, void *dest, int mixmode, float mixfactor);
 
bool CustomData_data_equals(eCustomDataType type, const void *data1, const void *data2);
void CustomData_data_initminmax(eCustomDataType type, void *min, void *max);
void CustomData_data_dominmax(eCustomDataType type, const void *data, void *min, void *max);
void CustomData_data_multiply(eCustomDataType type, void *data, float fac);
void CustomData_data_add(eCustomDataType type, void *data1, const void *data2);
 
void CustomData_init_from(const CustomData *source,
                          CustomData *dest,
                          eCustomDataMask mask,
                          int totelem);
void CustomData_init_layout_from(const CustomData *source,
                                 CustomData *dest,
                                 eCustomDataMask mask,
                                 eCDAllocType alloctype,
                                 int totelem);
 
/* BMESH_TODO, not really a public function but `readfile.cc` needs it. */
void CustomData_update_typemap(CustomData *data);
 
bool CustomData_merge(const CustomData *source,
                      CustomData *dest,
                      eCustomDataMask mask,
                      int totelem);
bool CustomData_merge_layout(const CustomData *source,
                             CustomData *dest,
                             eCustomDataMask mask,
                             eCDAllocType alloctype,
                             int totelem);
 
void CustomData_realloc(CustomData *data,
                        int old_size,
                        int new_size,
                        eCDAllocType alloctype = CD_CONSTRUCT);
 
bool CustomData_bmesh_merge_layout(const CustomData *source,
                                   CustomData *dest,
                                   eCustomDataMask mask,
                                   eCDAllocType alloctype,
                                   BMesh *bm,
                                   char htype);
 
CustomData CustomData_shallow_copy_remove_non_bmesh_attributes(const CustomData *src,
                                                               eCustomDataMask mask);
 
void CustomData_reset(CustomData *data);
 
void CustomData_free(CustomData *data, int totelem);
 
void CustomData_free_typemask(CustomData *data, int totelem, eCustomDataMask mask);
 
void *CustomData_add_layer(CustomData *data,
                           eCustomDataType type,
                           eCDAllocType alloctype,
                           int totelem);
 
const void *CustomData_add_layer_with_data(CustomData *data,
                                           eCustomDataType type,
                                           void *layer_data,
                                           int totelem,
                                           const blender::ImplicitSharingInfo *sharing_info);
 
void *CustomData_add_layer_named(CustomData *data,
                                 eCustomDataType type,
                                 eCDAllocType alloctype,
                                 int totelem,
                                 blender::StringRef name);
 
const void *CustomData_add_layer_named_with_data(CustomData *data,
                                                 eCustomDataType type,
                                                 void *layer_data,
                                                 int totelem,
                                                 blender::StringRef name,
                                                 const blender::ImplicitSharingInfo *sharing_info);
 
bool CustomData_free_layer(CustomData *data, eCustomDataType type, int totelem, int index);
bool CustomData_free_layer_named(CustomData *data, blender::StringRef name, const int totelem);
 
bool CustomData_free_layer_active(CustomData *data, eCustomDataType type, int totelem);
 
void CustomData_free_layers(CustomData *data, eCustomDataType type, int totelem);
 
bool CustomData_has_layer(const CustomData *data, eCustomDataType type);
bool CustomData_has_layer_named(const CustomData *data,
                                eCustomDataType type,
                                blender::StringRef name);
 
int CustomData_number_of_layers(const CustomData *data, eCustomDataType type);
int CustomData_number_of_anonymous_layers(const CustomData *data, eCustomDataType type);
int CustomData_number_of_layers_typemask(const CustomData *data, eCustomDataMask mask);
 
void CustomData_set_only_copy(const CustomData *data, eCustomDataMask mask);
 
void CustomData_copy_data(
    const CustomData *source, CustomData *dest, int source_index, int dest_index, int count);
void CustomData_copy_data_layer(const CustomData *source,
                                CustomData *dest,
                                int src_layer_index,
                                int dst_layer_index,
                                int src_index,
                                int dst_index,
                                int count);
void CustomData_copy_data_named(
    const CustomData *source, CustomData *dest, int source_index, int dest_index, int count);
void CustomData_copy_elements(eCustomDataType type,
                              void *src_data_ofs,
                              void *dst_data_ofs,
                              int count);
 
void CustomData_bmesh_copy_block(CustomData &data, void *src_block, void **dst_block);
 
struct BMCustomDataCopyMap {
  struct TrivialCopy {
    int size;
    int src_offset;
    int dst_offset;
  };
  struct Copy {
    cd_copy fn;
    int src_offset;
    int dst_offset;
  };
  struct TrivialDefault {
    int size;
    int dst_offset;
  };
  struct Default {
    cd_set_default_value fn;
    int dst_offset;
  };
  struct Free {
    cd_free fn;
    int dst_offset;
  };
  blender::Vector<TrivialCopy> trivial_copies;
  blender::Vector<Copy> copies;
  blender::Vector<TrivialDefault> trivial_defaults;
  blender::Vector<Default> defaults;
  blender::Vector<Free> free;
};
 
BMCustomDataCopyMap CustomData_bmesh_copy_map_calc(const CustomData &src,
                                                   const CustomData &dst,
                                                   eCustomDataMask mask_exclude = 0);
 
void CustomData_bmesh_copy_block(CustomData &dst_data,
                                 const BMCustomDataCopyMap &map,
                                 const void *src_block,
                                 void **dst_block);
 
void CustomData_copy_layer_type_data(const CustomData *source,
                                     CustomData *destination,
                                     eCustomDataType type,
                                     int source_index,
                                     int destination_index,
                                     int count);
 
void CustomData_free_elem(CustomData *data, int index, int count);
 
void CustomData_interp(const CustomData *source,
                       CustomData *dest,
                       const int *src_indices,
                       const float *weights,
                       const float *sub_weights,
                       int count,
                       int dest_index);
void CustomData_bmesh_interp_n(CustomData *data,
                               const void **src_blocks,
                               const float *weights,
                               const float *sub_weights,
                               int count,
                               void *dst_block_ofs,
                               int n);
void CustomData_bmesh_interp(CustomData *data,
                             const void **src_blocks,
                             const float *weights,
                             const float *sub_weights,
                             int count,
                             void *dst_block);
 
void CustomData_swap_corners(CustomData *data, int index, const int *corner_indices);
 
void CustomData_ensure_data_is_mutable(CustomDataLayer *layer, int totelem);
void CustomData_ensure_layers_are_mutable(CustomData *data, int totelem);
 
void *CustomData_get_for_write(CustomData *data, int index, eCustomDataType type, int totelem);
void *CustomData_get_n_for_write(
    CustomData *data, eCustomDataType type, int index, int n, int totelem);
 
/* BMesh Custom Data Functions.
 * Should replace edit-mesh ones with these as well, due to more efficient memory alloc. */
 
void *CustomData_bmesh_get(const CustomData *data, void *block, eCustomDataType type);
void *CustomData_bmesh_get_n(const CustomData *data, void *block, eCustomDataType type, int n);
 
void *CustomData_bmesh_get_layer_n(const CustomData *data, void *block, int n);
 
bool CustomData_set_layer_name(CustomData *data,
                               eCustomDataType type,
                               int n,
                               blender::StringRef name);
const char *CustomData_get_layer_name(const CustomData *data, eCustomDataType type, int n);
 
const void *CustomData_get_layer(const CustomData *data, eCustomDataType type);
void *CustomData_get_layer_for_write(CustomData *data, eCustomDataType type, int totelem);
 
const void *CustomData_get_layer_n(const CustomData *data, eCustomDataType type, int n);
void *CustomData_get_layer_n_for_write(CustomData *data, eCustomDataType type, int n, int totelem);
 
const void *CustomData_get_layer_named(const CustomData *data,
                                       eCustomDataType type,
                                       blender::StringRef name);
void *CustomData_get_layer_named_for_write(CustomData *data,
                                           eCustomDataType type,
                                           blender::StringRef name,
                                           int totelem);
 
int CustomData_get_offset(const CustomData *data, eCustomDataType type);
int CustomData_get_offset_named(const CustomData *data,
                                eCustomDataType type,
                                blender::StringRef name);
int CustomData_get_n_offset(const CustomData *data, eCustomDataType type, int n);
 
int CustomData_get_layer_index(const CustomData *data, eCustomDataType type);
int CustomData_get_layer_index_n(const CustomData *data, eCustomDataType type, int n);
int CustomData_get_named_layer_index(const CustomData *data,
                                     eCustomDataType type,
                                     blender::StringRef name);
int CustomData_get_named_layer_index_notype(const CustomData *data, blender::StringRef name);
int CustomData_get_active_layer_index(const CustomData *data, eCustomDataType type);
int CustomData_get_render_layer_index(const CustomData *data, eCustomDataType type);
int CustomData_get_clone_layer_index(const CustomData *data, eCustomDataType type);
int CustomData_get_stencil_layer_index(const CustomData *data, eCustomDataType type);
int CustomData_get_named_layer(const CustomData *data,
                               eCustomDataType type,
                               blender::StringRef name);
int CustomData_get_active_layer(const CustomData *data, eCustomDataType type);
int CustomData_get_render_layer(const CustomData *data, eCustomDataType type);
int CustomData_get_clone_layer(const CustomData *data, eCustomDataType type);
int CustomData_get_stencil_layer(const CustomData *data, eCustomDataType type);
 
const char *CustomData_get_active_layer_name(const CustomData *data, eCustomDataType type);
 
const char *CustomData_get_render_layer_name(const CustomData *data, eCustomDataType type);
 
bool CustomData_layer_is_anonymous(const CustomData *data, eCustomDataType type, int n);
 
void CustomData_bmesh_set_n(
    CustomData *data, void *block, eCustomDataType type, int n, const void *source);
 
void CustomData_set_layer_active(CustomData *data, eCustomDataType type, int n);
void CustomData_set_layer_render(CustomData *data, eCustomDataType type, int n);
void CustomData_set_layer_clone(CustomData *data, eCustomDataType type, int n);
void CustomData_set_layer_stencil(CustomData *data, eCustomDataType type, int n);
 
void CustomData_set_layer_active_index(CustomData *data, eCustomDataType type, int n);
void CustomData_set_layer_render_index(CustomData *data, eCustomDataType type, int n);
void CustomData_set_layer_clone_index(CustomData *data, eCustomDataType type, int n);
void CustomData_set_layer_stencil_index(CustomData *data, eCustomDataType type, int n);
 
void CustomData_set_layer_flag(CustomData *data, eCustomDataType type, int flag);
void CustomData_clear_layer_flag(CustomData *data, eCustomDataType type, int flag);
 
void CustomData_bmesh_set_default(CustomData *data, void **block);
void CustomData_bmesh_free_block(CustomData *data, void **block);
void CustomData_bmesh_alloc_block(CustomData *data, void **block);
 
void CustomData_bmesh_free_block_data(CustomData *data, void *block);
void CustomData_bmesh_free_block_data_exclude_by_type(CustomData *data,
                                                      void *block,
                                                      eCustomDataMask mask_exclude);
 
void CustomData_file_write_info(eCustomDataType type,
                                const char **r_struct_name,
                                int *r_struct_num);
int CustomData_sizeof(eCustomDataType type);
 
const char *CustomData_layertype_name(eCustomDataType type);
bool CustomData_layertype_is_singleton(eCustomDataType type);
bool CustomData_layertype_is_dynamic(eCustomDataType type);
int CustomData_layertype_layers_max(eCustomDataType type);
 
int CustomData_name_maxncpy_calc(blender::StringRef name);
 
void CustomData_set_layer_unique_name(CustomData *data, int index);
 
void CustomData_validate_layer_name(const CustomData *data,
                                    eCustomDataType type,
                                    blender::StringRef name,
                                    char *outname);
 
bool CustomData_verify_versions(CustomData *data, int index);
 
/* BMesh specific custom-data stuff. */
 
void CustomData_bmesh_init_pool(CustomData *data, int totelem, char htype);
 
bool CustomData_layer_validate(CustomDataLayer *layer, uint totitems, bool do_fixes);
 
/* External file storage */
 
void CustomData_external_add(
    CustomData *data, ID *id, eCustomDataType type, int totelem, const char *filepath);
void CustomData_external_remove(CustomData *data, ID *id, eCustomDataType type, int totelem);
bool CustomData_external_test(CustomData *data, eCustomDataType type);
 
void CustomData_external_write(
    CustomData *data, ID *id, eCustomDataMask mask, int totelem, int free);
void CustomData_external_read(CustomData *data, ID *id, eCustomDataMask mask, int totelem);
void CustomData_external_reload(CustomData *data, ID *id, eCustomDataMask mask, int totelem);
 
/* Mesh-to-mesh transfer data. */
 
using cd_datatransfer_interp = void (*)(const CustomDataTransferLayerMap *laymap,
                                        void *dest,
                                        const void **sources,
                                        const float *weights,
                                        int count,
                                        float mix_factor);
 
enum {
  CD_FAKE = 1 << 8,
 
  /* Vertices. */
  CD_FAKE_MDEFORMVERT = CD_FAKE | CD_MDEFORMVERT, /* *sigh* due to how vgroups are stored :(. */
  CD_FAKE_SHAPEKEY = CD_FAKE |
                     CD_SHAPEKEY, /* Not available as real CD layer in non-bmesh context. */
 
  /* Edges. */
  CD_FAKE_SEAM = CD_FAKE | 100, /* UV seam flag for edges. */
 
  /* Multiple types of mesh elements... */
  CD_FAKE_UV =
      CD_FAKE |
      CD_PROP_FLOAT2, /* UV flag, because we handle both loop's UVs and face's textures. */
 
  CD_FAKE_LNOR = CD_FAKE |
                 CD_CUSTOMLOOPNORMAL, /* Because we play with clnor and temp lnor layers here. */
 
  CD_FAKE_SHARP = CD_FAKE | 200, /* Sharp flag for edges, smooth flag for faces. */
 
  CD_FAKE_BWEIGHT = CD_FAKE | 300,
  CD_FAKE_CREASE = CD_FAKE | 400,
};
 
enum {
  ME_VERT = 1 << 0,
  ME_EDGE = 1 << 1,
  ME_POLY = 1 << 2,
  ME_LOOP = 1 << 3,
};
 
enum {
  CDT_MIX_NOMIX = -1, /* Special case, only used because we abuse 'copy' CD callback. */
  CDT_MIX_TRANSFER = 0,
  CDT_MIX_REPLACE_ABOVE_THRESHOLD = 1,
  CDT_MIX_REPLACE_BELOW_THRESHOLD = 2,
  CDT_MIX_MIX = 16,
  CDT_MIX_ADD = 17,
  CDT_MIX_SUB = 18,
  CDT_MIX_MUL = 19,
  /* Etc. */
};
 
struct CustomDataTransferLayerMap {
  CustomDataTransferLayerMap *next, *prev;
 
  int data_type;
  int mix_mode;
  float mix_factor;
  const float *mix_weights;
 
  const void *data_src;
  void *data_dst;
  int data_src_n;
  int data_dst_n;
  size_t elem_size;
 
  size_t data_size;
  size_t data_offset;
  uint64_t data_flag;
 
  void *interp_data;
 
  cd_datatransfer_interp interp;
};
 
void CustomData_data_transfer(const MeshPairRemap *me_remap,
                              const CustomDataTransferLayerMap *laymap);
 
/* .blend file I/O */
 
void CustomData_blend_write_prepare(CustomData &data,
                                    blender::Vector<CustomDataLayer, 16> &layers_to_write,
                                    const blender::Set<std::string> &skip_names = {});
 
void CustomData_blend_write(BlendWriter *writer,
                            CustomData *data,
                            blender::Span<CustomDataLayer> layers_to_write,
                            int count,
                            eCustomDataMask cddata_mask,
                            ID *id);
 
void CustomData_blend_read(BlendDataReader *reader, CustomData *data, int count);
 
size_t CustomData_get_elem_size(const CustomDataLayer *layer);
 
void CustomData_count_memory(const CustomData &data, int totelem, blender::MemoryCounter &memory);
 
#ifndef NDEBUG
struct DynStr;
void CustomData_debug_info_from_layers(const CustomData *data, const char *indent, DynStr *dynstr);
#endif /* !NDEBUG */
 
namespace blender::bke {
std::optional<VolumeGridType> custom_data_type_to_volume_grid_type(eCustomDataType type);
std::optional<eCustomDataType> volume_grid_type_to_custom_data_type(VolumeGridType type);
}  // namespace blender::bke