Physically based defaults for Eevee Bloom and Shutter
[blender.git] / source / blender / blenkernel / BKE_armature.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27 #ifndef __BKE_ARMATURE_H__
28 #define __BKE_ARMATURE_H__
29
30 /** \file BKE_armature.h
31  *  \ingroup bke
32  *  \since March 2001
33  *  \author nzc
34  */
35
36 struct bPose;
37 struct Bone;
38 struct Depsgraph;
39 struct GHash;
40 struct Main;
41 struct bArmature;
42 struct bPoseChannel;
43 struct bConstraint;
44 struct Scene;
45 struct Object;
46 struct PoseTree;
47 struct ListBase;
48
49 typedef struct PoseTarget {
50         struct PoseTarget *next, *prev;
51
52         struct bConstraint *con;        /* the constraint of this target */
53         int tip;                        /* index of tip pchan in PoseTree */
54 } PoseTarget;
55
56 typedef struct PoseTree {
57         struct PoseTree *next, *prev;
58
59         int type;                       /* type of IK that this serves (CONSTRAINT_TYPE_KINEMATIC or ..._SPLINEIK) */
60         int totchannel;                 /* number of pose channels */
61
62         struct ListBase targets;        /* list of targets of the tree */
63         struct bPoseChannel **pchan;    /* array of pose channels */
64         int     *parent;                /* and their parents */
65
66         float (*basis_change)[3][3];    /* basis change result from solver */
67         int iterations;                 /* iterations from the constraint */
68         int stretch;                    /* disable stretching */
69 } PoseTree;
70
71 /*      Core armature functionality */
72 #ifdef __cplusplus
73 extern "C" {
74 #endif
75
76 struct bArmature *BKE_armature_add(struct Main *bmain, const char *name);
77 struct bArmature *BKE_armature_from_object(struct Object *ob);
78 int  BKE_armature_bonelist_count(struct ListBase *lb);
79 void BKE_armature_bonelist_free(struct ListBase *lb);
80 void BKE_armature_free(struct bArmature *arm);
81 void BKE_armature_make_local(struct Main *bmain, struct bArmature *arm, const bool lib_local);
82 void BKE_armature_copy_data(struct Main *bmain, struct bArmature *arm_dst, const struct bArmature *arm_src, const int flag);
83 struct bArmature *BKE_armature_copy(struct Main *bmain, const struct bArmature *arm);
84
85 /* Bounding box. */
86 struct BoundBox *BKE_armature_boundbox_get(struct Object *ob);
87
88 bool BKE_pose_minmax(struct Object *ob, float r_min[3], float r_max[3], bool use_hidden, bool use_select);
89
90 int bone_autoside_name(char name[64], int strip_number, short axis, float head, float tail);
91
92 struct Bone  *BKE_armature_find_bone_name(struct bArmature *arm, const char *name);
93 struct GHash *BKE_armature_bone_from_name_map(struct bArmature *arm);
94
95 bool         BKE_armature_bone_flag_test_recursive(const struct Bone *bone, int flag);
96
97 float distfactor_to_bone(const float vec[3], const float b1[3], const float b2[3], float r1, float r2, float rdist);
98
99 void BKE_armature_where_is(struct bArmature *arm);
100 void BKE_armature_where_is_bone(struct Bone *bone, struct Bone *prevbone, const bool use_recursion);
101 void BKE_pose_clear_pointers(struct bPose *pose);
102 void BKE_pose_remap_bone_pointers(struct bArmature *armature, struct bPose *pose);
103 void BKE_pchan_rebuild_bbone_handles(struct bPose *pose, struct bPoseChannel *pchan);
104 void BKE_pose_rebuild(struct Main *bmain, struct Object *ob, struct bArmature *arm, const bool do_id_user);
105 void BKE_pose_where_is(struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob);
106 void BKE_pose_where_is_bone(struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob, struct bPoseChannel *pchan, float ctime, bool do_extra);
107 void BKE_pose_where_is_bone_tail(struct bPoseChannel *pchan);
108
109 /* get_objectspace_bone_matrix has to be removed still */
110 void get_objectspace_bone_matrix(struct Bone *bone, float M_accumulatedMatrix[4][4], int root, int posed);
111 void vec_roll_to_mat3(const float vec[3], const float roll, float mat[3][3]);
112 void vec_roll_to_mat3_normalized(const float nor[3], const float roll, float mat[3][3]);
113 void mat3_to_vec_roll(const float mat[3][3], float r_vec[3], float *r_roll);
114 void mat3_vec_to_roll(const float mat[3][3], const float vec[3], float *r_roll);
115
116 /* Common Conversions Between Co-ordinate Spaces */
117 void BKE_armature_mat_world_to_pose(struct Object *ob, float inmat[4][4], float outmat[4][4]);
118 void BKE_armature_loc_world_to_pose(struct Object *ob, const float inloc[3], float outloc[3]);
119 void BKE_armature_mat_pose_to_bone(struct bPoseChannel *pchan, float inmat[4][4], float outmat[4][4]);
120 void BKE_armature_loc_pose_to_bone(struct bPoseChannel *pchan, const float inloc[3], float outloc[3]);
121 void BKE_armature_mat_bone_to_pose(struct bPoseChannel *pchan, float inmat[4][4], float outmat[4][4]);
122 void BKE_armature_mat_pose_to_delta(float delta_mat[4][4], float pose_mat[4][4], float arm_mat[4][4]);
123
124 void BKE_armature_mat_pose_to_bone_ex(struct Depsgraph *depsgraph, struct Object *ob, struct bPoseChannel *pchan, float inmat[4][4], float outmat[4][4]);
125
126 void BKE_pchan_mat3_to_rot(struct bPoseChannel *pchan, float mat[3][3], bool use_compat);
127 void BKE_pchan_apply_mat4(struct bPoseChannel *pchan, float mat[4][4], bool use_comat);
128 void BKE_pchan_to_mat4(struct bPoseChannel *pchan, float chan_mat[4][4]);
129 void BKE_pchan_calc_mat(struct bPoseChannel *pchan);
130
131 /* Simple helper, computes the offset bone matrix. */
132 void BKE_bone_offset_matrix_get(const struct Bone *bone, float offs_bone[4][4]);
133
134 /* Transformation inherited from the parent bone. These matrices apply the effects of
135  * HINGE/NO_SCALE/NO_LOCAL_LOCATION options over the pchan loc/rot/scale transformations. */
136 typedef struct BoneParentTransform {
137         float rotscale_mat[4][4];       /* parent effect on rotation & scale pose channels */
138         float loc_mat[4][4];            /* parent effect on location pose channel */
139 } BoneParentTransform;
140
141 /* Matrix-like algebra operations on the transform */
142 void BKE_bone_parent_transform_clear(struct BoneParentTransform *bpt);
143 void BKE_bone_parent_transform_invert(struct BoneParentTransform *bpt);
144 void BKE_bone_parent_transform_combine(
145         const struct BoneParentTransform *in1, const struct BoneParentTransform *in2,
146         struct BoneParentTransform *result);
147
148 void BKE_bone_parent_transform_apply(
149         const struct BoneParentTransform *bpt, const float inmat[4][4], float outmat[4][4]);
150
151 /* Get the current parent transformation for the given pose bone. */
152 void BKE_bone_parent_transform_calc_from_pchan(
153         const struct bPoseChannel *pchan,
154         struct BoneParentTransform *r_bpt);
155 void BKE_bone_parent_transform_calc_from_matrices(
156         int bone_flag, const float offs_bone[4][4], const float parent_arm_mat[4][4], const float parent_pose_mat[4][4],
157         struct BoneParentTransform *r_bpt);
158
159 /* Rotation Mode Conversions - Used for PoseChannels + Objects... */
160 void BKE_rotMode_change_values(float quat[4], float eul[3], float axis[3], float *angle, short oldMode, short newMode);
161
162 /* B-Bone support */
163 #define MAX_BBONE_SUBDIV    32
164
165 typedef struct Mat4 {
166         float mat[4][4];
167 } Mat4;
168
169 typedef struct BBoneSplineParameters {
170         int segments;
171         float length;
172
173         /* Non-uniform scale correction. */
174         bool do_scale;
175         float scale[3];
176
177         /* Handle control bone data. */
178         bool use_prev, prev_bbone;
179         bool use_next, next_bbone;
180
181         float prev_h[3], next_h[3];
182         float prev_mat[4][4], next_mat[4][4];
183
184         /* Control values. */
185         float ease1, ease2;
186         float roll1, roll2;
187         float scaleIn, scaleOut;
188         float curveInX, curveInY, curveOutX, curveOutY;
189 } BBoneSplineParameters;
190
191 void BKE_pchan_bbone_handles_get(
192         struct bPoseChannel *pchan, struct bPoseChannel **r_prev, struct bPoseChannel **r_next);
193 void BKE_pchan_bbone_spline_params_get(
194         struct bPoseChannel *pchan, const bool rest, struct BBoneSplineParameters *r_param);
195
196 void BKE_pchan_bbone_spline_setup(
197         struct bPoseChannel *pchan, const bool rest, Mat4 result_array[MAX_BBONE_SUBDIV]);
198
199 void BKE_pchan_bbone_handles_compute(
200         const BBoneSplineParameters *param,
201         float h1[3], float *r_roll1,
202         float h2[3], float *r_roll2,
203         bool ease, bool offsets);
204 int  BKE_pchan_bbone_spline_compute(
205         struct BBoneSplineParameters *param, Mat4 result_array[MAX_BBONE_SUBDIV]);
206
207 void BKE_pchan_bbone_segments_cache_compute(
208         struct bPoseChannel *pchan);
209 void BKE_pchan_bbone_segments_cache_copy(
210         struct bPoseChannel *pchan, struct bPoseChannel *pchan_from);
211
212 /* like EBONE_VISIBLE */
213 #define PBONE_VISIBLE(arm, bone) ( \
214         CHECK_TYPE_INLINE(arm, bArmature *), \
215         CHECK_TYPE_INLINE(bone, Bone *), \
216         (((bone)->layer & (arm)->layer) && !((bone)->flag & BONE_HIDDEN_P)) \
217         )
218
219 #define PBONE_SELECTABLE(arm, bone) \
220         (PBONE_VISIBLE(arm, bone) && !((bone)->flag & BONE_UNSELECTABLE))
221
222
223 /* context.selected_pose_bones */
224 #define FOREACH_PCHAN_SELECTED_IN_OBJECT_BEGIN(_ob, _pchan) \
225         for (bPoseChannel *_pchan = (_ob)->pose->chanbase.first; _pchan;  _pchan = _pchan->next) { \
226                 if (PBONE_VISIBLE(((bArmature *)(_ob)->data), (_pchan)->bone) && ((_pchan)->bone->flag & BONE_SELECTED)) {
227 #define FOREACH_PCHAN_SELECTED_IN_OBJECT_END \
228                 } \
229         } ((void)0)
230 /* context.visible_pose_bones */
231 #define FOREACH_PCHAN_VISIBLE_IN_OBJECT_BEGIN(_ob, _pchan) \
232         for (bPoseChannel *_pchan = (_ob)->pose->chanbase.first; _pchan;  _pchan = _pchan->next) { \
233                 if (PBONE_VISIBLE(((bArmature *)(_ob)->data), (_pchan)->bone)) {
234 #define FOREACH_PCHAN_VISIBLE_IN_OBJECT_END \
235                 } \
236         } ((void)0)
237
238
239 /* Evaluation helpers */
240 struct bKinematicConstraint;
241 struct bPose;
242 struct bSplineIKConstraint;
243
244 struct bPoseChannel *BKE_armature_ik_solver_find_root(
245         struct bPoseChannel *pchan,
246         struct bKinematicConstraint *data);
247 struct bPoseChannel *BKE_armature_splineik_solver_find_root(
248         struct bPoseChannel *pchan,
249         struct bSplineIKConstraint *data);
250
251 void BKE_pose_splineik_init_tree(struct Scene *scene, struct Object *ob, float ctime);
252 void BKE_splineik_execute_tree(
253         struct Depsgraph *depsgraph, struct Scene *scene,
254         struct Object *ob, struct bPoseChannel *pchan_root, float ctime);
255
256 void BKE_pose_eval_init(
257         struct Depsgraph *depsgraph,
258         struct Scene *scene,
259         struct Object *object);
260
261 void BKE_pose_eval_init_ik(
262         struct Depsgraph *depsgraph,
263         struct Scene *scene,
264         struct Object *object);
265
266 void BKE_pose_eval_bone(
267         struct Depsgraph *depsgraph,
268         struct Scene *scene,
269         struct Object *object,
270         int pchan_index);
271
272 void BKE_pose_constraints_evaluate(
273         struct Depsgraph *depsgraph,
274         struct Scene *scene,
275         struct Object *object,
276         int pchan_index);
277
278 void BKE_pose_bone_done(
279         struct Depsgraph *depsgraph,
280         struct Object *object,
281         int pchan_index);
282
283 void BKE_pose_eval_bbone_segments(
284         struct Depsgraph *depsgraph,
285         struct Object *object,
286         int pchan_index);
287
288 void BKE_pose_iktree_evaluate(
289         struct Depsgraph *depsgraph,
290         struct Scene *scene,
291         struct Object *object,
292         int rootchan_index);
293
294 void BKE_pose_splineik_evaluate(
295         struct Depsgraph *depsgraph,
296         struct Scene *scene,
297         struct Object *object,
298         int rootchan_index);
299
300 void BKE_pose_eval_done(
301         struct Depsgraph *depsgraph,
302         struct Object *object);
303
304 void BKE_pose_eval_cleanup(
305         struct Depsgraph *depsgraph,
306         struct Scene *scene,
307         struct Object *object);
308
309 void BKE_pose_eval_proxy_init(struct Depsgraph *depsgraph,
310                               struct Object *object);
311 void BKE_pose_eval_proxy_done(struct Depsgraph *depsgraph,
312                               struct Object *object);
313 void BKE_pose_eval_proxy_cleanup(struct Depsgraph *depsgraph,
314                                  struct Object *object);
315
316 void BKE_pose_eval_proxy_copy_bone(
317         struct Depsgraph *depsgraph,
318         struct Object *object,
319         int pchan_index);
320
321 /* BBOne deformation cache.
322  *
323  * The idea here is to pre-calculate deformation queternions, matricies and such
324  * used by armature_deform_verts().
325  */
326 struct ObjectBBoneDeform;
327 struct ObjectBBoneDeform * BKE_armature_cached_bbone_deformation_get(
328         struct Object *object);
329 void BKE_armature_cached_bbone_deformation_free_data(struct Object *object);
330 void BKE_armature_cached_bbone_deformation_free(struct Object *object);
331 void BKE_armature_cached_bbone_deformation_update(struct Object *object);
332
333 #ifdef __cplusplus
334 }
335 #endif
336
337 #endif