2011-02-18 14:05:18 +01:00
|
|
|
/*
|
2002-10-12 13:37:38 +02:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
2008-04-17 00:40:48 +02:00
|
|
|
* of the License, or (at your option) any later version.
|
2002-10-12 13:37:38 +02:00
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software Foundation,
|
2010-02-12 14:34:04 +01:00
|
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
2002-10-12 13:37:38 +02:00
|
|
|
*/
|
|
|
|
|
2012-02-17 19:59:41 +01:00
|
|
|
#ifndef __BKE_OBJECT_H__
|
|
|
|
#define __BKE_OBJECT_H__
|
2002-10-12 13:37:38 +02:00
|
|
|
|
2019-02-17 22:08:12 +01:00
|
|
|
/** \file
|
|
|
|
* \ingroup bke
|
|
|
|
* \brief General operations, lookup, etc. for blender objects.
|
2011-02-18 14:05:18 +01:00
|
|
|
*/
|
2020-05-08 18:16:39 +02:00
|
|
|
|
|
|
|
#include "BLI_compiler_attrs.h"
|
2020-06-16 18:03:36 +02:00
|
|
|
#include "BLI_sys_types.h"
|
2020-05-08 18:16:39 +02:00
|
|
|
|
|
|
|
#include "DNA_object_enums.h"
|
|
|
|
|
2002-10-12 13:37:38 +02:00
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
2017-11-24 10:18:16 +01:00
|
|
|
struct Base;
|
2019-01-28 11:08:24 +01:00
|
|
|
struct BoundBox;
|
2018-04-06 12:07:27 +02:00
|
|
|
struct Depsgraph;
|
2018-07-31 10:22:19 +02:00
|
|
|
struct GpencilModifierData;
|
2019-01-28 11:08:24 +01:00
|
|
|
struct HookGpencilModifierData;
|
|
|
|
struct HookModifierData;
|
2018-07-31 10:22:19 +02:00
|
|
|
struct ID;
|
2013-02-05 13:46:15 +01:00
|
|
|
struct Main;
|
2018-05-25 12:27:54 +02:00
|
|
|
struct Mesh;
|
2015-05-12 10:38:55 +02:00
|
|
|
struct ModifierData;
|
2019-01-28 11:08:24 +01:00
|
|
|
struct MovieClip;
|
|
|
|
struct Object;
|
2018-11-19 19:33:09 +01:00
|
|
|
struct RegionView3D;
|
2019-01-28 11:08:24 +01:00
|
|
|
struct RigidBodyWorld;
|
|
|
|
struct Scene;
|
|
|
|
struct ShaderFxData;
|
|
|
|
struct View3D;
|
|
|
|
struct ViewLayer;
|
2002-10-12 13:37:38 +02:00
|
|
|
|
2012-05-05 16:03:12 +02:00
|
|
|
void BKE_object_workob_clear(struct Object *workob);
|
2019-04-17 06:17:24 +02:00
|
|
|
void BKE_object_workob_calc_parent(struct Depsgraph *depsgraph,
|
|
|
|
struct Scene *scene,
|
|
|
|
struct Object *ob,
|
|
|
|
struct Object *workob);
|
2008-12-24 12:08:15 +01:00
|
|
|
|
2012-05-22 17:29:57 +02:00
|
|
|
void BKE_object_transform_copy(struct Object *ob_tar, const struct Object *ob_src);
|
2018-07-03 18:20:44 +02:00
|
|
|
void BKE_object_copy_softbody(struct Object *ob_dst, const struct Object *ob_src, const int flag);
|
Refactor ID copying (and to some extent, ID freeing).
This will allow much finer controll over how we copy data-blocks, from
full copy in Main database, to "lighter" ones (out of Main, inside an
already allocated datablock, etc.).
This commit also transfers a llot of what was previously handled by
per-ID-type custom code to generic ID handling code in BKE_library.
Hopefully will avoid in future inconsistencies and missing bits we had
all over the codebase in the past.
It also adds missing copying handling for a few types, most notably
Scene (which where using a fully customized handling previously).
Note that the type of allocation used during copying (regular in Main,
allocated but outside of Main, or not allocated by ID handling code at
all) is stored in ID's, which allows to handle them correctly when
freeing. This needs to be taken care of with caution when doing 'weird'
unusual things with ID copying and/or allocation!
As a final note, while rather noisy, this commit will hopefully not
break too much existing branches, old 'API' has been kept for the main
part, as a wrapper around new code. Cleaning it up will happen later.
Design task : T51804
Phab Diff: D2714
2017-08-07 16:39:55 +02:00
|
|
|
struct ParticleSystem *BKE_object_copy_particlesystem(struct ParticleSystem *psys, const int flag);
|
2019-04-17 06:17:24 +02:00
|
|
|
void BKE_object_copy_particlesystems(struct Object *ob_dst,
|
|
|
|
const struct Object *ob_src,
|
|
|
|
const int flag);
|
2016-12-28 17:30:58 +01:00
|
|
|
void BKE_object_free_particlesystems(struct Object *ob);
|
2012-05-05 16:03:12 +02:00
|
|
|
void BKE_object_free_softbody(struct Object *ob);
|
2013-08-19 11:25:24 +02:00
|
|
|
void BKE_object_free_curve_cache(struct Object *ob);
|
2005-11-27 21:49:25 +01:00
|
|
|
|
2013-05-18 12:24:34 +02:00
|
|
|
void BKE_object_free_derived_caches(struct Object *ob);
|
2015-02-17 13:27:15 +01:00
|
|
|
void BKE_object_free_caches(struct Object *object);
|
2010-01-04 17:26:07 +01:00
|
|
|
|
2013-10-15 22:15:45 +02:00
|
|
|
void BKE_object_modifier_hook_reset(struct Object *ob, struct HookModifierData *hmd);
|
2019-04-17 06:17:24 +02:00
|
|
|
void BKE_object_modifier_gpencil_hook_reset(struct Object *ob,
|
|
|
|
struct HookGpencilModifierData *hmd);
|
2018-07-31 10:22:19 +02:00
|
|
|
bool BKE_object_modifier_gpencil_use_time(struct Object *ob, struct GpencilModifierData *md);
|
|
|
|
|
|
|
|
bool BKE_object_shaderfx_use_time(struct Object *ob, struct ShaderFxData *md);
|
2013-10-15 22:15:45 +02:00
|
|
|
|
2018-04-14 14:27:38 +02:00
|
|
|
bool BKE_object_support_modifier_type_check(const struct Object *ob, int modifier_type);
|
2012-03-12 15:35:07 +01:00
|
|
|
|
2020-03-03 12:35:51 +01:00
|
|
|
void BKE_object_link_modifiers(struct Object *ob_dst, const struct Object *ob_src);
|
2018-04-04 14:56:32 +02:00
|
|
|
void BKE_object_free_modifiers(struct Object *ob, const int flag);
|
2018-07-31 10:22:19 +02:00
|
|
|
void BKE_object_free_shaderfx(struct Object *ob, const int flag);
|
2005-11-27 21:49:25 +01:00
|
|
|
|
2019-04-17 06:17:24 +02:00
|
|
|
void BKE_object_make_proxy(struct Main *bmain,
|
|
|
|
struct Object *ob,
|
|
|
|
struct Object *target,
|
|
|
|
struct Object *gob);
|
2012-05-05 16:03:12 +02:00
|
|
|
void BKE_object_copy_proxy_drivers(struct Object *ob, struct Object *target);
|
2006-11-11 17:45:17 +01:00
|
|
|
|
2018-05-31 12:27:47 +02:00
|
|
|
bool BKE_object_exists_check(struct Main *bmain, const struct Object *obtest);
|
2018-04-14 14:27:38 +02:00
|
|
|
bool BKE_object_is_in_editmode(const struct Object *ob);
|
|
|
|
bool BKE_object_is_in_editmode_vgroup(const struct Object *ob);
|
2018-04-05 18:20:27 +02:00
|
|
|
bool BKE_object_is_in_wpaint_select_vert(const struct Object *ob);
|
2018-04-16 16:27:55 +02:00
|
|
|
bool BKE_object_has_mode_data(const struct Object *ob, eObjectMode object_mode);
|
2018-05-29 15:43:53 +02:00
|
|
|
bool BKE_object_is_mode_compat(const struct Object *ob, eObjectMode object_mode);
|
2017-12-21 16:29:14 +01:00
|
|
|
|
2018-05-30 10:15:36 +02:00
|
|
|
bool BKE_object_data_is_in_editmode(const struct ID *id);
|
|
|
|
|
2019-11-07 06:52:03 +01:00
|
|
|
char *BKE_object_data_editmode_flush_ptr_get(struct ID *id);
|
|
|
|
|
2019-05-08 09:45:20 +02:00
|
|
|
void BKE_object_update_select_id(struct Main *bmain);
|
|
|
|
|
2018-12-18 18:18:00 +01:00
|
|
|
typedef enum eObjectVisibilityResult {
|
2019-04-17 06:17:24 +02:00
|
|
|
OB_VISIBLE_SELF = 1,
|
|
|
|
OB_VISIBLE_PARTICLES = 2,
|
|
|
|
OB_VISIBLE_INSTANCES = 4,
|
|
|
|
OB_VISIBLE_ALL = (OB_VISIBLE_SELF | OB_VISIBLE_PARTICLES | OB_VISIBLE_INSTANCES),
|
2018-12-18 18:18:00 +01:00
|
|
|
} eObjectVisibilityResult;
|
|
|
|
|
|
|
|
int BKE_object_visibility(const struct Object *ob, const int dag_eval_mode);
|
2012-12-17 15:51:06 +01:00
|
|
|
|
2019-04-17 06:17:24 +02:00
|
|
|
struct Object *BKE_object_add_only_object(struct Main *bmain, int type, const char *name)
|
|
|
|
ATTR_NONNULL(1) ATTR_RETURNS_NONNULL;
|
|
|
|
struct Object *BKE_object_add(struct Main *bmain,
|
|
|
|
struct Scene *scene,
|
|
|
|
struct ViewLayer *view_layer,
|
|
|
|
int type,
|
|
|
|
const char *name) ATTR_NONNULL(1, 2, 3) ATTR_RETURNS_NONNULL;
|
|
|
|
struct Object *BKE_object_add_from(struct Main *bmain,
|
|
|
|
struct Scene *scene,
|
|
|
|
struct ViewLayer *view_layer,
|
|
|
|
int type,
|
|
|
|
const char *name,
|
|
|
|
struct Object *ob_src)
|
|
|
|
ATTR_NONNULL(1, 2, 3, 6) ATTR_RETURNS_NONNULL;
|
|
|
|
struct Object *BKE_object_add_for_data(struct Main *bmain,
|
|
|
|
struct ViewLayer *view_layer,
|
|
|
|
int type,
|
|
|
|
const char *name,
|
|
|
|
struct ID *data,
|
|
|
|
bool do_id_user) ATTR_RETURNS_NONNULL;
|
|
|
|
void *BKE_object_obdata_add_from_type(struct Main *bmain, int type, const char *name)
|
|
|
|
ATTR_NONNULL(1);
|
|
|
|
|
2017-06-14 22:36:30 +02:00
|
|
|
struct Object *BKE_object_copy(struct Main *bmain, const struct Object *ob);
|
2018-04-14 14:27:38 +02:00
|
|
|
bool BKE_object_is_libdata(const struct Object *ob);
|
|
|
|
bool BKE_object_obdata_is_libdata(const struct Object *ob);
|
2012-05-05 16:03:12 +02:00
|
|
|
|
2019-04-17 06:17:24 +02:00
|
|
|
struct Object *BKE_object_duplicate(struct Main *bmain,
|
2020-06-17 15:02:04 +02:00
|
|
|
struct Object *ob,
|
2020-07-09 15:33:34 +02:00
|
|
|
uint dupflag,
|
2020-06-17 15:02:04 +02:00
|
|
|
const uint duplicate_options);
|
2019-02-26 20:15:30 +01:00
|
|
|
|
2014-09-01 12:09:31 +02:00
|
|
|
void BKE_object_obdata_size_init(struct Object *ob, const float scale);
|
|
|
|
|
2012-12-11 15:29:01 +01:00
|
|
|
void BKE_object_scale_to_mat3(struct Object *ob, float mat[3][3]);
|
2019-05-01 05:15:44 +02:00
|
|
|
void BKE_object_rot_to_mat3(const struct Object *ob, float mat[3][3], bool use_drot);
|
2013-03-21 00:14:18 +01:00
|
|
|
void BKE_object_mat3_to_rot(struct Object *ob, float mat[3][3], bool use_compat);
|
2012-12-11 15:29:01 +01:00
|
|
|
void BKE_object_to_mat3(struct Object *ob, float mat[3][3]);
|
|
|
|
void BKE_object_to_mat4(struct Object *ob, float mat[4][4]);
|
2019-04-17 06:17:24 +02:00
|
|
|
void BKE_object_apply_mat4(struct Object *ob,
|
|
|
|
float mat[4][4],
|
|
|
|
const bool use_compat,
|
|
|
|
const bool use_parent);
|
|
|
|
void BKE_object_apply_mat4_ex(struct Object *ob,
|
|
|
|
float mat[4][4],
|
|
|
|
struct Object *parent,
|
|
|
|
float parentinv[4][4],
|
|
|
|
const bool use_compat);
|
2013-07-12 14:58:01 +02:00
|
|
|
void BKE_object_matrix_local_get(struct Object *ob, float mat[4][4]);
|
2012-05-05 16:03:12 +02:00
|
|
|
|
2018-04-14 14:27:38 +02:00
|
|
|
bool BKE_object_pose_context_check(const struct Object *ob);
|
2012-05-05 16:03:12 +02:00
|
|
|
struct Object *BKE_object_pose_armature_get(struct Object *ob);
|
2019-04-17 06:17:24 +02:00
|
|
|
struct Object *BKE_object_pose_armature_get_visible(struct Object *ob,
|
|
|
|
struct ViewLayer *view_layer,
|
|
|
|
struct View3D *v3d);
|
|
|
|
|
|
|
|
struct Object **BKE_object_pose_array_get_ex(struct ViewLayer *view_layer,
|
|
|
|
struct View3D *v3d,
|
|
|
|
unsigned int *r_objects_len,
|
|
|
|
bool unique);
|
|
|
|
struct Object **BKE_object_pose_array_get_unique(struct ViewLayer *view_layer,
|
|
|
|
struct View3D *v3d,
|
|
|
|
unsigned int *r_objects_len);
|
|
|
|
struct Object **BKE_object_pose_array_get(struct ViewLayer *view_layer,
|
|
|
|
struct View3D *v3d,
|
|
|
|
unsigned int *r_objects_len);
|
|
|
|
|
|
|
|
struct Base **BKE_object_pose_base_array_get_ex(struct ViewLayer *view_layer,
|
|
|
|
struct View3D *v3d,
|
|
|
|
unsigned int *r_bases_len,
|
|
|
|
bool unique);
|
|
|
|
struct Base **BKE_object_pose_base_array_get_unique(struct ViewLayer *view_layer,
|
|
|
|
struct View3D *v3d,
|
|
|
|
unsigned int *r_bases_len);
|
|
|
|
struct Base **BKE_object_pose_base_array_get(struct ViewLayer *view_layer,
|
|
|
|
struct View3D *v3d,
|
|
|
|
unsigned int *r_bases_len);
|
|
|
|
|
|
|
|
void BKE_object_get_parent_matrix(struct Object *ob, struct Object *par, float parentmat[4][4]);
|
|
|
|
void BKE_object_where_is_calc(struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob);
|
|
|
|
void BKE_object_where_is_calc_ex(struct Depsgraph *depsgraph,
|
|
|
|
struct Scene *scene,
|
|
|
|
struct RigidBodyWorld *rbw,
|
|
|
|
struct Object *ob,
|
|
|
|
float r_originmat[3][3]);
|
|
|
|
void BKE_object_where_is_calc_time(struct Depsgraph *depsgraph,
|
|
|
|
struct Scene *scene,
|
|
|
|
struct Object *ob,
|
|
|
|
float ctime);
|
2018-12-19 11:20:32 +01:00
|
|
|
void BKE_object_where_is_calc_mat4(struct Object *ob, float obmat[4][4]);
|
2012-05-05 16:03:12 +02:00
|
|
|
|
|
|
|
/* possibly belong in own moduke? */
|
|
|
|
struct BoundBox *BKE_boundbox_alloc_unit(void);
|
2013-06-09 23:25:27 +02:00
|
|
|
void BKE_boundbox_init_from_minmax(struct BoundBox *bb, const float min[3], const float max[3]);
|
2014-08-11 05:25:25 +02:00
|
|
|
void BKE_boundbox_calc_center_aabb(const struct BoundBox *bb, float r_cent[3]);
|
|
|
|
void BKE_boundbox_calc_size_aabb(const struct BoundBox *bb, float r_size[3]);
|
2019-04-17 06:17:24 +02:00
|
|
|
void BKE_boundbox_minmax(const struct BoundBox *bb,
|
|
|
|
float obmat[4][4],
|
|
|
|
float r_min[3],
|
|
|
|
float r_max[3]);
|
2012-05-05 16:03:12 +02:00
|
|
|
|
|
|
|
struct BoundBox *BKE_object_boundbox_get(struct Object *ob);
|
|
|
|
void BKE_object_dimensions_get(struct Object *ob, float vec[3]);
|
2019-09-06 12:00:45 +02:00
|
|
|
void BKE_object_dimensions_set_ex(struct Object *ob,
|
|
|
|
const float value[3],
|
|
|
|
int axis_mask,
|
|
|
|
const float ob_scale_orig[3],
|
|
|
|
const float ob_obmat_orig[4][4]);
|
2019-01-04 09:52:13 +01:00
|
|
|
void BKE_object_dimensions_set(struct Object *ob, const float value[3], int axis_mask);
|
2019-09-06 12:00:45 +02:00
|
|
|
|
2014-01-13 21:57:05 +01:00
|
|
|
void BKE_object_empty_draw_type_set(struct Object *ob, const int value);
|
2014-08-11 05:25:25 +02:00
|
|
|
void BKE_object_boundbox_flag(struct Object *ob, int flag, const bool set);
|
2018-10-15 08:14:05 +02:00
|
|
|
void BKE_object_boundbox_calc_from_mesh(struct Object *ob, struct Mesh *me_eval);
|
2013-03-21 00:14:18 +01:00
|
|
|
void BKE_object_minmax(struct Object *ob, float r_min[3], float r_max[3], const bool use_hidden);
|
2019-04-17 06:17:24 +02:00
|
|
|
bool BKE_object_minmax_dupli(struct Depsgraph *depsgraph,
|
|
|
|
struct Scene *scene,
|
|
|
|
struct Object *ob,
|
|
|
|
float r_min[3],
|
|
|
|
float r_max[3],
|
|
|
|
const bool use_hidden);
|
2011-11-14 04:54:23 +01:00
|
|
|
|
2012-03-18 08:38:51 +01:00
|
|
|
/* sometimes min-max isn't enough, we need to loop over each point */
|
2019-04-17 06:17:24 +02:00
|
|
|
void BKE_object_foreach_display_point(struct Object *ob,
|
|
|
|
float obmat[4][4],
|
|
|
|
void (*func_cb)(const float[3], void *),
|
|
|
|
void *user_data);
|
|
|
|
void BKE_scene_foreach_display_point(struct Depsgraph *depsgraph,
|
|
|
|
void (*func_cb)(const float[3], void *),
|
|
|
|
void *user_data);
|
2011-11-14 04:54:23 +01:00
|
|
|
|
2013-03-09 06:35:49 +01:00
|
|
|
bool BKE_object_parent_loop_check(const struct Object *parent, const struct Object *ob);
|
2011-12-16 11:39:43 +01:00
|
|
|
|
2012-05-05 16:03:12 +02:00
|
|
|
void *BKE_object_tfm_backup(struct Object *ob);
|
2019-04-17 06:17:24 +02:00
|
|
|
void BKE_object_tfm_restore(struct Object *ob, void *obtfm_pt);
|
2010-02-26 09:47:20 +01:00
|
|
|
|
2011-11-11 06:34:07 +01:00
|
|
|
typedef struct ObjectTfmProtectedChannels {
|
2019-04-17 06:17:24 +02:00
|
|
|
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;
|
2011-11-11 06:34:07 +01:00
|
|
|
} ObjectTfmProtectedChannels;
|
|
|
|
|
2019-04-17 06:17:24 +02:00
|
|
|
void BKE_object_tfm_protected_backup(const struct Object *ob, ObjectTfmProtectedChannels *obtfm);
|
2011-11-11 06:34:07 +01:00
|
|
|
|
2019-04-17 06:17:24 +02:00
|
|
|
void BKE_object_tfm_protected_restore(struct Object *ob,
|
|
|
|
const ObjectTfmProtectedChannels *obtfm,
|
|
|
|
const short protectflag);
|
2011-11-11 06:34:07 +01:00
|
|
|
|
2019-04-17 06:17:24 +02:00
|
|
|
void BKE_object_tfm_copy(struct Object *object_dst, const struct Object *object_src);
|
2018-12-14 11:40:33 +01:00
|
|
|
|
2019-04-17 06:17:24 +02:00
|
|
|
void BKE_object_eval_reset(struct Object *ob_eval);
|
2018-12-14 11:40:33 +01:00
|
|
|
|
2015-05-12 09:50:24 +02:00
|
|
|
/* Dependency graph evaluation callbacks. */
|
2019-04-17 06:17:24 +02:00
|
|
|
void BKE_object_eval_local_transform(struct Depsgraph *depsgraph, struct Object *ob);
|
|
|
|
void BKE_object_eval_parent(struct Depsgraph *depsgraph, struct Object *ob);
|
|
|
|
void BKE_object_eval_constraints(struct Depsgraph *depsgraph,
|
|
|
|
struct Scene *scene,
|
|
|
|
struct Object *ob);
|
|
|
|
void BKE_object_eval_transform_final(struct Depsgraph *depsgraph, struct Object *ob);
|
|
|
|
|
|
|
|
bool BKE_object_eval_proxy_copy(struct Depsgraph *depsgraph, struct Object *object);
|
|
|
|
void BKE_object_eval_uber_transform(struct Depsgraph *depsgraph, struct Object *ob);
|
|
|
|
void BKE_object_eval_uber_data(struct Depsgraph *depsgraph,
|
|
|
|
struct Scene *scene,
|
|
|
|
struct Object *ob);
|
2020-02-27 11:23:15 +01:00
|
|
|
void BKE_object_eval_assign_data(struct Object *object, struct ID *data, bool is_owned);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
|
|
|
void BKE_object_eval_boundbox(struct Depsgraph *depsgraph, struct Object *object);
|
2020-04-03 07:46:34 +02:00
|
|
|
void BKE_object_sync_to_original(struct Depsgraph *depsgraph, struct Object *object);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
|
|
|
void BKE_object_eval_ptcache_reset(struct Depsgraph *depsgraph,
|
|
|
|
struct Scene *scene,
|
|
|
|
struct Object *object);
|
|
|
|
|
|
|
|
void BKE_object_eval_transform_all(struct Depsgraph *depsgraph,
|
|
|
|
struct Scene *scene,
|
|
|
|
struct Object *object);
|
|
|
|
|
|
|
|
void BKE_object_data_select_update(struct Depsgraph *depsgraph, struct ID *object_data);
|
2019-07-02 15:14:47 +02:00
|
|
|
void BKE_object_select_update(struct Depsgraph *depsgraph, struct Object *object);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
|
|
|
void BKE_object_eval_eval_base_flags(struct Depsgraph *depsgraph,
|
|
|
|
struct Scene *scene,
|
|
|
|
const int view_layer_index,
|
|
|
|
struct Object *object,
|
|
|
|
int base_index,
|
|
|
|
const bool is_from_set);
|
2017-11-24 10:18:16 +01:00
|
|
|
|
2018-06-11 14:39:38 +02:00
|
|
|
void BKE_object_handle_data_update(struct Depsgraph *depsgraph,
|
2019-04-17 06:17:24 +02:00
|
|
|
struct Scene *scene,
|
|
|
|
struct Object *ob);
|
|
|
|
void BKE_object_handle_update(struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob);
|
|
|
|
void BKE_object_handle_update_ex(struct Depsgraph *depsgraph,
|
|
|
|
struct Scene *scene,
|
|
|
|
struct Object *ob,
|
|
|
|
struct RigidBodyWorld *rbw,
|
|
|
|
const bool do_proxy_update);
|
Result of 2 weeks of quiet coding work in Greece :)
Aim was to get a total refresh of the animation system. This
is needed because;
- we need to upgrade it with 21st century features
- current code is spaghetti/hack combo, and hides good design
- it should become lag-free with using dependency graphs
A full log, with complete code API/structure/design explanation
will follow, that's a load of work... so here below the list with
hot changes;
- The entire object update system (matrices, geometry) is now
centralized. Calls to where_is_object and makeDispList are
forbidden, instead we tag objects 'changed' and let the
depgraph code sort it out
- Removed all old "Ika" code
- Depgraph is aware of all relationships, including meta balls,
constraints, bevelcurve, and so on.
- Made depgraph aware of relation types and layers, to do smart
flushing of 'changed' events. Nothing gets calculated too often!
- Transform uses depgraph to detect changes
- On frame-advance, depgraph flushes animated changes
Armatures;
Almost all armature related code has been fully built from scratch.
It now reveils the original design much better, with a very clean
implementation, lag free without even calculating each Bone more than
once. Result is quite a speedup yes!
Important to note is;
1) Armature is data containing the 'rest position'
2) Pose is the changes of rest position, and always on object level.
That way more Objects can use same Pose. Also constraints are in Pose
3) Actions only contain the Ipos to change values in Poses.
- Bones draw unrotated now
- Drawing bones speedup enormously (10-20 times)
- Bone selecting in EditMode, selection state is saved for PoseMode,
and vice-versa
- Undo in editmode
- Bone renaming does vertexgroups, constraints, posechannels, actions,
for all users of Armature in entire file
- Added Bone renaming in NKey panel
- Nkey PoseMode shows eulers now
- EditMode and PoseMode now have 'active' bone too (last clicked)
- Parenting in EditMode' CTRL+P, ALT+P, with nice options!
- Pose is added in Outliner now, with showing that constraints are in
the Pose, not Armature
- Disconnected IK solving from constraints. It's a separate phase now,
on top of the full Pose calculations
- Pose itself has a dependency graph too, so evaluation order is lag free.
TODO NOW;
- Rotating in Posemode has incorrect inverse transform (Martin will fix)
- Python Bone/Armature/Pose API disabled... needs full recode too
(wait for my doc!)
- Game engine will need upgrade too
- Depgraph code needs revision, cleanup, can be much faster!
(But, compliments for Jean-Luc, it works like a charm!)
- IK changed, it now doesnt use previous position to advance to next
position anymore. That system looks nice (no flips) but is not well
suited for NLA and background render.
TODO LATER;
We now can do loadsa new nifty features as well; like:
- Kill PoseMode (can be option for armatures itself)
- Make B-Bones (Bezier, Bspline, like for spines)
- Move all silly button level edit to 3d window (like CTRL+I = add
IK)
- Much better & informative drawing
- Fix action/nla editors
- Put all ipos in Actions (object, mesh key, lamp color)
- Add hooks
- Null bones
- Much more advanced constraints...
Bugfixes;
- OGL render (view3d header) had wrong first frame on anim render
- Ipo 'recording' mode had wrong playback speed
- Vertex-key mode now sticks to show 'active key', until frame change
-Ton-
2005-07-03 19:35:38 +02:00
|
|
|
|
2019-01-09 00:16:51 +01:00
|
|
|
void BKE_object_sculpt_data_create(struct Object *ob);
|
|
|
|
|
2019-09-23 15:54:21 +02:00
|
|
|
int BKE_object_obdata_texspace_get(struct Object *ob,
|
|
|
|
short **r_texflag,
|
|
|
|
float **r_loc,
|
|
|
|
float **r_size);
|
2009-08-25 20:41:36 +02:00
|
|
|
|
2020-02-27 11:23:15 +01:00
|
|
|
struct Mesh *BKE_object_get_evaluated_mesh(struct Object *object);
|
2018-06-04 16:20:39 +02:00
|
|
|
struct Mesh *BKE_object_get_pre_modified_mesh(struct Object *object);
|
2018-06-04 15:48:37 +02:00
|
|
|
struct Mesh *BKE_object_get_original_mesh(struct Object *object);
|
2018-05-25 12:27:54 +02:00
|
|
|
|
2012-05-05 16:03:12 +02:00
|
|
|
int BKE_object_insert_ptcache(struct Object *ob);
|
2014-02-05 18:46:10 +01:00
|
|
|
void BKE_object_delete_ptcache(struct Object *ob, int index);
|
2019-04-17 06:17:24 +02:00
|
|
|
struct KeyBlock *BKE_object_shapekey_insert(struct Main *bmain,
|
|
|
|
struct Object *ob,
|
|
|
|
const char *name,
|
|
|
|
const bool from_mix);
|
2015-06-08 11:49:01 +02:00
|
|
|
bool BKE_object_shapekey_remove(struct Main *bmain, struct Object *ob, struct KeyBlock *kb);
|
|
|
|
bool BKE_object_shapekey_free(struct Main *bmain, struct Object *ob);
|
2009-08-25 20:41:36 +02:00
|
|
|
|
2015-03-04 04:38:16 +01:00
|
|
|
bool BKE_object_flag_test_recursive(const struct Object *ob, short flag);
|
|
|
|
|
2018-04-14 14:27:38 +02:00
|
|
|
bool BKE_object_is_child_recursive(const struct Object *ob_parent, const struct Object *ob_child);
|
2013-03-09 06:35:49 +01:00
|
|
|
|
|
|
|
/* return ModifierMode flag */
|
2012-05-05 16:03:12 +02:00
|
|
|
int BKE_object_is_modified(struct Scene *scene, struct Object *ob);
|
|
|
|
int BKE_object_is_deform_modified(struct Scene *scene, struct Object *ob);
|
2011-03-16 09:53:35 +01:00
|
|
|
|
2019-11-26 17:59:27 +01:00
|
|
|
bool BKE_object_moves_in_time(const struct Object *object, bool recurse_parent);
|
|
|
|
|
2019-02-09 13:18:22 +01:00
|
|
|
int BKE_object_scenes_users_get(struct Main *bmain, struct Object *ob);
|
|
|
|
|
2019-04-17 06:17:24 +02:00
|
|
|
struct MovieClip *BKE_object_movieclip_get(struct Scene *scene,
|
|
|
|
struct Object *ob,
|
|
|
|
bool use_default);
|
2011-11-07 13:55:18 +01:00
|
|
|
|
2018-05-30 11:49:45 +02:00
|
|
|
void BKE_object_runtime_reset(struct Object *object);
|
2019-02-13 14:29:27 +01:00
|
|
|
void BKE_object_runtime_reset_on_copy(struct Object *object, const int flag);
|
2018-05-30 11:49:45 +02:00
|
|
|
|
2018-08-23 15:14:29 +02:00
|
|
|
void BKE_object_batch_cache_dirty_tag(struct Object *ob);
|
2018-08-22 22:02:37 +02:00
|
|
|
|
2012-06-12 23:23:51 +02:00
|
|
|
/* this function returns a superset of the scenes selection based on relationships */
|
|
|
|
|
|
|
|
typedef enum eObRelationTypes {
|
2019-04-17 06:17:24 +02:00
|
|
|
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 */
|
2020-02-20 00:21:23 +01:00
|
|
|
/* OB_REL_SCENE_CAMERA = (1 << 5), */ /* you might want the scene camera too even if unselected?
|
|
|
|
*/
|
2012-06-12 23:23:51 +02:00
|
|
|
} eObRelationTypes;
|
|
|
|
|
|
|
|
typedef enum eObjectSet {
|
2019-04-17 06:17:24 +02:00
|
|
|
OB_SET_SELECTED, /* Selected Objects */
|
|
|
|
OB_SET_VISIBLE, /* Visible Objects */
|
|
|
|
OB_SET_ALL, /* All Objects */
|
2012-06-12 23:23:51 +02:00
|
|
|
} eObjectSet;
|
|
|
|
|
2019-04-17 06:17:24 +02:00
|
|
|
struct LinkNode *BKE_object_relational_superset(struct ViewLayer *view_layer,
|
|
|
|
eObjectSet objectSet,
|
|
|
|
eObRelationTypes includeFilter);
|
2019-03-12 23:55:33 +01:00
|
|
|
struct LinkNode *BKE_object_groups(struct Main *bmain, struct Scene *scene, struct Object *ob);
|
2019-04-17 06:17:24 +02:00
|
|
|
void BKE_object_groups_clear(struct Main *bmain, struct Scene *scene, struct Object *object);
|
2012-06-12 23:23:51 +02:00
|
|
|
|
2019-03-19 14:46:33 +01:00
|
|
|
struct KDTree_3d *BKE_object_as_kdtree(struct Object *ob, int *r_tot);
|
2013-09-02 00:01:21 +02:00
|
|
|
|
2015-05-12 10:38:55 +02:00
|
|
|
bool BKE_object_modifier_use_time(struct Object *ob, struct ModifierData *md);
|
|
|
|
|
2019-04-17 06:17:24 +02:00
|
|
|
bool BKE_object_modifier_update_subframe(struct Depsgraph *depsgraph,
|
|
|
|
struct Scene *scene,
|
|
|
|
struct Object *ob,
|
|
|
|
bool update_mesh,
|
|
|
|
int parent_recursion,
|
|
|
|
float frame,
|
|
|
|
int type);
|
2016-01-09 04:37:53 +01:00
|
|
|
|
2019-04-17 06:17:24 +02:00
|
|
|
bool BKE_object_empty_image_frame_is_visible_in_view3d(const struct Object *ob,
|
|
|
|
const struct RegionView3D *rv3d);
|
|
|
|
bool BKE_object_empty_image_data_is_visible_in_view3d(const struct Object *ob,
|
|
|
|
const struct RegionView3D *rv3d);
|
2018-11-19 19:33:09 +01:00
|
|
|
|
2019-05-16 13:49:21 +02:00
|
|
|
/* This is an utility function for Python's object.to_mesh() (the naming is not very clear though).
|
|
|
|
* The result is owned by the object.
|
|
|
|
*
|
|
|
|
* The mesh will be freed when object is re-evaluated or is destroyed. It is possible to force to
|
2020-03-18 12:28:54 +01:00
|
|
|
* clear memory used by this mesh by calling BKE_object_to_mesh_clear().
|
2019-05-24 14:37:47 +02:00
|
|
|
*
|
|
|
|
* If preserve_all_data_layers is truth then the modifier stack is re-evaluated to ensure it
|
|
|
|
* preserves all possible custom data layers.
|
|
|
|
*
|
|
|
|
* NOTE: Dependency graph argument is required when preserve_all_data_layers is truth, and is
|
|
|
|
* ignored otherwise. */
|
|
|
|
struct Mesh *BKE_object_to_mesh(struct Depsgraph *depsgraph,
|
|
|
|
struct Object *object,
|
|
|
|
bool preserve_all_data_layers);
|
2019-05-16 13:49:21 +02:00
|
|
|
|
|
|
|
void BKE_object_to_mesh_clear(struct Object *object);
|
|
|
|
|
2002-10-12 13:37:38 +02:00
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|