BKE_object.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 "BLI_bounds_types.hh"
#include "BLI_compiler_attrs.h"
#include "BLI_function_ref.hh"
#include "BLI_math_matrix_types.hh"
#include "BLI_math_vector_types.hh"
#include "BLI_sys_types.h"
#include "BLI_vector.hh"
 
#include "DNA_object_enums.h"
#include "DNA_userdef_enums.h"
 
struct Base;
struct BoundBox;
struct Curve;
struct Depsgraph;
struct HookGpencilModifierData;
struct HookModifierData;
struct ID;
struct KDTree_3d;
struct KeyBlock;
struct Lattice;
struct LinkNode;
struct Main;
struct Mesh;
struct ModifierData;
struct MovieClip;
struct Object;
struct PartEff;
struct ParticleSystem;
struct RegionView3D;
struct RigidBodyWorld;
struct Scene;
struct SubsurfModifierData;
struct View3D;
struct ViewLayer;
 
void BKE_object_workob_clear(Object *workob);
blender::float4x4 BKE_object_calc_parent(Depsgraph *depsgraph, Scene *scene, Object *ob);
 
void BKE_object_transform_copy(Object *ob_tar, const Object *ob_src);
void BKE_object_copy_softbody(Object *ob_dst, const Object *ob_src, int flag);
ParticleSystem *BKE_object_copy_particlesystem(ParticleSystem *psys, int flag);
void BKE_object_copy_particlesystems(Object *ob_dst, const Object *ob_src, int flag);
void BKE_object_free_particlesystems(Object *ob);
void BKE_object_free_softbody(Object *ob);
void BKE_object_free_curve_cache(Object *ob);

void BKE_object_free_derived_caches(Object *ob);
void BKE_object_free_caches(Object *object);
 
void BKE_object_modifier_hook_reset(Object *ob, HookModifierData *hmd);
void BKE_object_modifier_gpencil_hook_reset(Object *ob, HookGpencilModifierData *hmd);

bool BKE_object_supports_modifiers(const Object *ob);
bool BKE_object_support_modifier_type_check(const Object *ob, int modifier_type);
 
/* Active modifier. */

void BKE_object_modifier_set_active(Object *ob, ModifierData *md);
ModifierData *BKE_object_active_modifier(const Object *ob);

bool BKE_object_copy_modifier(
    Main *bmain, const Scene *scene, Object *ob_dst, const Object *ob_src, const ModifierData *md);
bool BKE_object_modifier_stack_copy(Object *ob_dst,
                                    const Object *ob_src,
                                    bool do_copy_all,
                                    int flag_subdata);
void BKE_object_link_modifiers(Object *ob_dst, const Object *ob_src);
void BKE_object_free_modifiers(Object *ob, int flag);
void BKE_object_free_shaderfx(Object *ob, int flag);
 
bool BKE_object_exists_check(Main *bmain, const Object *obtest);
bool BKE_object_is_in_editmode(const Object *ob);
bool BKE_object_is_in_editmode_vgroup(const Object *ob);
bool BKE_object_is_in_wpaint_select_vert(const Object *ob);
bool BKE_object_has_mode_data(const Object *ob, eObjectMode object_mode);
bool BKE_object_is_mode_compat(const Object *ob, eObjectMode object_mode);
 
bool BKE_object_data_is_in_editmode(const Object *ob, const ID *id);
 
char *BKE_object_data_editmode_flush_ptr_get(ID *id);

void BKE_object_update_select_id(Main *bmain);
 
enum eObjectVisibilityResult {
  OB_VISIBLE_SELF = 1,
  OB_VISIBLE_PARTICLES = 2,
  OB_VISIBLE_INSTANCES = 4,
  OB_VISIBLE_ALL = (OB_VISIBLE_SELF | OB_VISIBLE_PARTICLES | OB_VISIBLE_INSTANCES),
};

int BKE_object_visibility(const Object *ob, int dag_eval_mode);

Object *BKE_object_add_only_object(Main *bmain, int type, const char *name) ATTR_RETURNS_NONNULL;
Object *BKE_object_add(Main *bmain,
                       Scene *scene,
                       ViewLayer *view_layer,
                       int type,
                       const char *name) ATTR_NONNULL(1, 2, 3) ATTR_RETURNS_NONNULL;
Object *BKE_object_add_from(
    Main *bmain, Scene *scene, ViewLayer *view_layer, int type, const char *name, Object *ob_src)
    ATTR_NONNULL(1, 2, 3, 6) ATTR_RETURNS_NONNULL;
Object *BKE_object_add_for_data(Main *bmain,
                                const Scene *scene,
                                ViewLayer *view_layer,
                                int type,
                                const char *name,
                                ID *data,
                                bool do_id_user) ATTR_RETURNS_NONNULL;
void *BKE_object_obdata_add_from_type(Main *bmain, int type, const char *name) ATTR_NONNULL(1);
int BKE_object_obdata_to_type(const ID *id) ATTR_NONNULL(1);

bool BKE_object_is_libdata(const Object *ob);
bool BKE_object_obdata_is_libdata(const Object *ob);

Object *BKE_object_duplicate(Main *bmain,
                             Object *ob,
                             eDupli_ID_Flags dupflag,
                             /*eLibIDDuplicateFlags*/ uint duplicate_options);

void BKE_object_obdata_size_init(Object *ob, float size);
 
void BKE_object_scale_to_mat3(const Object *ob, float r_mat[3][3]);
void BKE_object_rot_to_mat3(const Object *ob, float r_mat[3][3], bool use_drot);
void BKE_object_mat3_to_rot(Object *ob, float r_mat[3][3], bool use_compat);
void BKE_object_to_mat3(const Object *ob, float r_mat[3][3]);
void BKE_object_to_mat4(const Object *ob, float r_mat[4][4]);
void BKE_object_apply_mat4_ex(Object *ob,
                              const float mat[4][4],
                              Object *parent,
                              const float parentinv[4][4],
                              bool use_compat);
void BKE_object_apply_mat4(Object *ob, const float mat[4][4], bool use_compat, bool use_parent);

void BKE_object_apply_parent_inverse(Object *ob);
 
void BKE_object_matrix_local_get(Object *ob, float r_mat[4][4]);
 
bool BKE_object_pose_context_check(const Object *ob);
 
Object *BKE_object_pose_armature_get(Object *ob);
Object *BKE_object_pose_armature_get_with_wpaint_check(Object *ob);
Object *BKE_object_pose_armature_get_visible(Object *ob,
                                             const Scene *scene,
                                             ViewLayer *view_layer,
                                             View3D *v3d);

blender::Vector<Object *> BKE_object_pose_array_get_ex(const Scene *scene,
                                                       ViewLayer *view_layer,
                                                       View3D *v3d,
                                                       bool unique);
blender::Vector<Object *> BKE_object_pose_array_get_unique(const Scene *scene,
                                                           ViewLayer *view_layer,
                                                           View3D *v3d);
blender::Vector<Object *> BKE_object_pose_array_get(const Scene *scene,
                                                    ViewLayer *view_layer,
                                                    View3D *v3d);
 
blender::Vector<Base *> BKE_object_pose_base_array_get_ex(const Scene *scene,
                                                          ViewLayer *view_layer,
                                                          View3D *v3d,
                                                          bool unique);
blender::Vector<Base *> BKE_object_pose_base_array_get_unique(const Scene *scene,
                                                              ViewLayer *view_layer,
                                                              View3D *v3d);
blender::Vector<Base *> BKE_object_pose_base_array_get(const Scene *scene,
                                                       ViewLayer *view_layer,
                                                       View3D *v3d);
 
void BKE_object_get_parent_matrix(const Object *ob, Object *par, float r_parentmat[4][4]);

void BKE_object_where_is_calc(Depsgraph *depsgraph, Scene *scene, Object *ob);
void BKE_object_where_is_calc_ex(
    Depsgraph *depsgraph, Scene *scene, RigidBodyWorld *rbw, Object *ob, float r_originmat[3][3]);
void BKE_object_where_is_calc_time(Depsgraph *depsgraph, Scene *scene, Object *ob, float ctime);
void BKE_object_where_is_calc_mat4(const Object *ob, float r_obmat[4][4]);
 
/* Possibly belong in its own module? */
 
void BKE_boundbox_init_from_minmax(BoundBox *bb, const float min[3], const float max[3]);
void BKE_boundbox_minmax(const BoundBox &bb,
                         const blender::float4x4 &matrix,
                         blender::float3 &r_min,
                         blender::float3 &r_max);

std::optional<blender::Bounds<blender::float3>> BKE_object_evaluated_geometry_bounds(
    const Object *ob);

std::optional<blender::Bounds<blender::float3>> BKE_object_boundbox_get(const Object *ob);

void BKE_object_dimensions_get(const Object *ob, float r_vec[3]);

std::optional<blender::Bounds<blender::float3>> BKE_object_boundbox_eval_cached_get(
    const Object *ob);

void BKE_object_dimensions_eval_cached_get(const Object *ob, float r_vec[3]);

void BKE_object_dimensions_set_ex(Object *ob,
                                  const float value[3],
                                  int axis_mask,
                                  const float ob_scale_orig[3],
                                  const float ob_obmat_orig[4][4]);
void BKE_object_dimensions_set(Object *ob, const float value[3], int axis_mask);
 
void BKE_object_empty_draw_type_set(Object *ob, int value);
 
void BKE_object_minmax(Object *ob, blender::float3 &r_min, blender::float3 &r_max);
bool BKE_object_minmax_dupli(Depsgraph *depsgraph,
                             Scene *scene,
                             Object *ob,
                             blender::float3 &r_min,
                             blender::float3 &r_max,
                             bool use_hidden);
bool BKE_object_minmax_empty_drawtype(const Object *ob, float r_min[3], float r_max[3]);

void BKE_object_foreach_display_point(Object *ob,
                                      const float obmat[4][4],
                                      void (*func_cb)(const float[3], void *),
                                      void *user_data);
void BKE_scene_foreach_display_point(Depsgraph *depsgraph,
                                     void (*func_cb)(const float[3], void *),
                                     void *user_data);
 
bool BKE_object_parent_loop_check(const Object *parent, const Object *ob);
 
void *BKE_object_tfm_backup(Object *ob);
void BKE_object_tfm_restore(Object *ob, void *obtfm_pt);
 
struct ObjectTfmProtectedChannels {
  float loc[3], dloc[3];
  float scale[3], dscale[3];
  float rot[3], drot[3];
  float quat[4], dquat[4];
  float rotAxis[3], drotAxis[3];
  float rotAngle, drotAngle;
};
 
void BKE_object_tfm_protected_backup(const Object *ob, ObjectTfmProtectedChannels *obtfm);
 
void BKE_object_tfm_protected_restore(Object *ob,
                                      const ObjectTfmProtectedChannels *obtfm,
                                      short protectflag);
 
void BKE_object_tfm_copy(Object *object_dst, const Object *object_src);

void BKE_object_eval_reset(Object *ob_eval);
 
/* Dependency graph evaluation callbacks. */
 
void BKE_object_eval_local_transform(Depsgraph *depsgraph, Object *ob);
void BKE_object_eval_parent(Depsgraph *depsgraph, Object *ob);
void BKE_object_eval_constraints(Depsgraph *depsgraph, Scene *scene, Object *ob);
void BKE_object_eval_transform_final(Depsgraph *depsgraph, Object *ob);
 
void BKE_object_eval_uber_transform(Depsgraph *depsgraph, Object *object);
void BKE_object_eval_uber_data(Depsgraph *depsgraph, Scene *scene, Object *ob);
 
void BKE_object_eval_shading(Depsgraph *depsgraph, Object *object);
 
void BKE_object_eval_light_linking(Depsgraph *depsgraph, Object *object);

void BKE_object_eval_assign_data(Object *object, ID *data, bool is_owned);
 
void BKE_object_sync_to_original(Depsgraph *depsgraph, Object *object);
 
void BKE_object_eval_ptcache_reset(Depsgraph *depsgraph, Scene *scene, Object *object);
 
void BKE_object_eval_transform_all(Depsgraph *depsgraph, Scene *scene, Object *object);
 
void BKE_object_data_select_update(Depsgraph *depsgraph, ID *object_data);
void BKE_object_select_update(Depsgraph *depsgraph, Object *object);
 
void BKE_object_eval_eval_base_flags(Depsgraph *depsgraph,
                                     Scene *scene,
                                     int view_layer_index,
                                     Object *object,
                                     int base_index,
                                     bool is_from_set);
 
void BKE_object_handle_data_update(Depsgraph *depsgraph, Scene *scene, Object *ob);
void BKE_object_handle_update(Depsgraph *depsgraph, Scene *scene, Object *ob);
void BKE_object_handle_update_ex(Depsgraph *depsgraph,
                                 Scene *scene,
                                 Object *ob,
                                 RigidBodyWorld *rbw);
 
void BKE_object_sculpt_data_create(Object *ob);
 
bool BKE_object_obdata_texspace_get(Object *ob,
                                    char **r_texspace_flag,
                                    float **r_texspace_location,
                                    float **r_texspace_size);
 
Mesh *BKE_object_get_evaluated_mesh_no_subsurf(const Object *object_eval);
Mesh *BKE_object_get_evaluated_mesh(const Object *object_eval);
Mesh *BKE_object_get_evaluated_mesh_no_subsurf_unchecked(const Object *object);
Mesh *BKE_object_get_evaluated_mesh_unchecked(const Object *object);
const Mesh *BKE_object_get_pre_modified_mesh(const Object *object);
Mesh *BKE_object_get_original_mesh(const Object *object);
 
const Mesh *BKE_object_get_editmesh_eval_final(const Object *object);
const Mesh *BKE_object_get_editmesh_eval_cage(const Object *object);
const Mesh *BKE_object_get_mesh_deform_eval(const Object *object);
 
/* Lattice accessors.
 * These functions return either the regular lattice, or the edit-mode lattice,
 * whichever is currently in use. */
 
Lattice *BKE_object_get_lattice(const Object *object);
Lattice *BKE_object_get_evaluated_lattice(const Object *object);
 
int BKE_object_insert_ptcache(Object *ob);
void BKE_object_delete_ptcache(Object *ob, int index);
KeyBlock *BKE_object_shapekey_insert(Main *bmain, Object *ob, const char *name, bool from_mix);
bool BKE_object_shapekey_remove(Main *bmain, Object *ob, KeyBlock *kb);
bool BKE_object_shapekey_free(Main *bmain, Object *ob);
 
bool BKE_object_flag_test_recursive(const Object *ob, short flag);
 
bool BKE_object_is_child_recursive(const Object *ob_parent, const Object *ob_child);

int BKE_object_is_modified(Scene *scene, Object *ob);
int BKE_object_is_deform_modified(Scene *scene, Object *ob);

bool BKE_object_moves_in_time(const Object *object, bool recurse_parent);

int BKE_object_scenes_users_get(Main *bmain, Object *ob);
 
MovieClip *BKE_object_movieclip_get(Scene *scene, const Object *ob, bool use_default);
 
void BKE_object_runtime_reset(Object *object);
void BKE_object_runtime_reset_on_copy(Object *object, int flag);
void BKE_object_runtime_free_data(Object *object);
 
void BKE_object_batch_cache_dirty_tag(Object *ob);
 
/* this function returns a superset of the scenes selection based on relationships */
 
enum eObRelationTypes {
  OB_REL_NONE = 0,                      /* Just the selection as is. */
  OB_REL_PARENT = (1 << 0),             /* Immediate parent. */
  OB_REL_PARENT_RECURSIVE = (1 << 1),   /* Parents up to root of selection tree. */
  OB_REL_CHILDREN = (1 << 2),           /* Immediate children. */
  OB_REL_CHILDREN_RECURSIVE = (1 << 3), /* All children. */
  OB_REL_MOD_ARMATURE = (1 << 4),       /* Armatures related to the selected objects. */
  // OB_REL_SCENE_CAMERA = (1 << 5), /* You might want the scene camera too even if unselected? */
};
 
enum eObjectSet {
  OB_SET_SELECTED, /* Selected Objects. */
  OB_SET_VISIBLE,  /* Visible Objects. */
  OB_SET_ALL,      /* All Objects. */
};

LinkNode *BKE_object_relational_superset(const Scene *scene,
                                         ViewLayer *view_layer,
                                         eObjectSet objectSet,
                                         eObRelationTypes includeFilter);
LinkNode *BKE_object_groups(Main *bmain, Scene *scene, Object *ob);
void BKE_object_groups_clear(Main *bmain, Scene *scene, Object *object);

KDTree_3d *BKE_object_as_kdtree(Object *ob, int *r_tot);

#define OBJECT_MODIFIER_UPDATE_SUBFRAME_RECURSION_DEFAULT 5

void BKE_object_modifier_update_subframe(Depsgraph *depsgraph,
                                         Scene *scene,
                                         Object *ob,
                                         bool update_mesh,
                                         int parent_recursion_limit,
                                         float frame,
                                         int /*ModifierType*/ modifier_type);

void BKE_object_modifier_update_subframe_only_callback(
    Object *ob,
    bool update_mesh,
    int parent_recursion_limit,
    int /*ModifierType*/ modifier_type,
    blender::FunctionRef<void(Object *object, bool update_mesh)> update_or_tag_fn);
 
bool BKE_object_empty_image_frame_is_visible_in_view3d(const Object *ob, const RegionView3D *rv3d);
bool BKE_object_empty_image_data_is_visible_in_view3d(const Object *ob, const RegionView3D *rv3d);

Mesh *BKE_object_to_mesh(Depsgraph *depsgraph, Object *object, bool preserve_all_data_layers);
 
void BKE_object_to_mesh_clear(Object *object);

Curve *BKE_object_to_curve(Object *object, Depsgraph *depsgraph, bool apply_modifiers);
 
void BKE_object_to_curve_clear(Object *object);
 
void BKE_object_check_uids_unique_and_report(const Object *object);

SubsurfModifierData *BKE_object_get_last_subsurf_modifier(const Object *ob);
 
void BKE_object_replace_data_on_shallow_copy(Object *ob, ID *new_data);
 
PartEff *BKE_object_do_version_give_parteff_245(Object *ob);
 
bool BKE_object_supports_material_slots(Object *ob);

void BKE_object_protected_location_set(Object *ob, const float location[3]);
void BKE_object_protected_scale_set(Object *ob, const float scale[3]);
void BKE_object_protected_rotation_quaternion_set(Object *ob, const float quat[4]);
void BKE_object_protected_rotation_euler_set(Object *ob, const float euler[3]);
void BKE_object_protected_rotation_axisangle_set(Object *ob, const float axis[3], float angle);