Graph editor: Add channel option to make it persistent on display
[blender.git] / source / blender / editors / include / ED_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  * Contributor(s): Blender Foundation
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file ED_armature.h
27  *  \ingroup editors
28  */
29
30 #ifndef __ED_ARMATURE_H__
31 #define __ED_ARMATURE_H__
32
33 #ifdef __cplusplus
34 extern "C" {
35 #endif
36
37 struct bArmature;
38 struct Base;
39 struct bContext;
40 struct Bone;
41 struct bPoseChannel;
42 struct IDProperty;
43 struct ListBase;
44 struct MeshDeformModifierData;
45 struct DerivedMesh;
46 struct Object;
47 struct ReportList;
48 struct Scene;
49 struct ViewContext;
50 struct wmKeyConfig;
51 struct wmOperator;
52
53 typedef struct EditBone {
54         struct EditBone *next, *prev;
55         struct IDProperty *prop; /* User-Defined Properties on this Bone */
56         struct EditBone *parent; /* Editbones have a one-way link  (i.e. children refer
57                                   * to parents.  This is converted to a two-way link for
58                                   * normal bones when leaving editmode. */
59         char    name[64];       /* MAXBONENAME */
60         float   roll;           /* Roll along axis.  We'll ultimately use the axis/angle method
61                                  * for determining the transformation matrix of the bone.  The axis
62                                  * is tail-head while roll provides the angle. Refer to Graphics
63                                  * Gems 1 p. 466 (section IX.6) if it's not already in here somewhere*/
64
65         float head[3];          /* Orientation and length is implicit during editing */
66         float tail[3];
67         /* All joints are considered to have zero rotation with respect to
68          * their parents.       Therefore any rotations specified during the
69          * animation are automatically relative to the bones' rest positions*/
70         int flag;
71         int layer;
72         
73         float dist, weight;
74         float xwidth, length, zwidth;  /* put them in order! transform uses this as scale */
75         float ease1, ease2;
76         float rad_head, rad_tail;
77         float roll1, roll2;
78         float curveOutX, curveOutY;
79         float curveInX, curveInY;
80         float scaleIn, scaleOut;
81         float oldlength;        /* for envelope scaling */
82         
83         short segments;
84
85         /* Used to store temporary data */
86         union {
87                 struct EditBone *ebone;
88                 struct Bone     *bone;
89                 void            *p;
90                 int              i;
91         } temp;
92 } EditBone;
93
94 #define BONESEL_ROOT    (1 << 28)
95 #define BONESEL_TIP     (1 << 29)
96 #define BONESEL_BONE    (1 << 30)
97 #define BONESEL_ANY     (BONESEL_TIP | BONESEL_ROOT | BONESEL_BONE)
98
99 #define BONESEL_NOSEL   (1u << 31u)
100
101 /* useful macros */
102 #define EBONE_VISIBLE(arm, ebone) ( \
103         CHECK_TYPE_INLINE(arm, bArmature *), \
104         CHECK_TYPE_INLINE(ebone, EditBone *), \
105         (((arm)->layer & (ebone)->layer) && !((ebone)->flag & BONE_HIDDEN_A)) \
106         )
107
108 #define EBONE_SELECTABLE(arm, ebone) (EBONE_VISIBLE(arm, ebone) && !(ebone->flag & BONE_UNSELECTABLE))
109
110 #define EBONE_EDITABLE(ebone) ( \
111         CHECK_TYPE_INLINE(ebone, EditBone *), \
112         (((ebone)->flag & BONE_SELECTED) && !((ebone)->flag & BONE_EDITMODE_LOCKED)) \
113         )
114
115 /* used in armature_select_hierarchy_exec() */
116 #define BONE_SELECT_PARENT  0
117 #define BONE_SELECT_CHILD   1
118
119 /* armature_ops.c */
120 void ED_operatortypes_armature(void);
121 void ED_operatormacros_armature(void);
122 void ED_keymap_armature(struct wmKeyConfig *keyconf);
123
124 /* editarmature.c */
125 void ED_armature_from_edit(struct bArmature *arm);
126 void ED_armature_to_edit(struct bArmature *arm);
127 void ED_armature_edit_free(struct bArmature *arm);
128 void ED_armature_ebone_listbase_temp_clear(struct ListBase *lb);
129
130 void ED_armature_deselect_all(struct Object *obedit);
131 void ED_armature_deselect_all_visible(struct Object *obedit);
132
133 int ED_do_pose_selectbuffer(struct Scene *scene, struct Base *base, unsigned int *buffer,
134                             short hits, bool extend, bool deselect, bool toggle, bool do_nearest);
135 bool ED_armature_select_pick(struct bContext *C, const int mval[2], bool extend, bool deselect, bool toggle);
136 int join_armature_exec(struct bContext *C, struct wmOperator *op);
137 struct Bone *get_indexed_bone(struct Object *ob, int index);
138 float ED_rollBoneToVector(EditBone *bone, const float new_up_axis[3], const bool axis_only);
139 EditBone *ED_armature_bone_find_name(const ListBase *edbo, const char *name);
140 EditBone *ED_armature_bone_get_mirrored(const struct ListBase *edbo, EditBone *ebo);
141 void ED_armature_sync_selection(struct ListBase *edbo);
142 void ED_armature_validate_active(struct bArmature *arm);
143
144 EditBone *ED_armature_edit_bone_add_primitive(struct Object *obedit_arm, float length, bool view_aligned);
145 EditBone *ED_armature_edit_bone_add(struct bArmature *arm, const char *name);
146 void ED_armature_edit_bone_remove(struct bArmature *arm, EditBone *exBone);
147
148 bool ED_armature_ebone_is_child_recursive(EditBone *ebone_parent, EditBone *ebone_child);
149 EditBone *ED_armature_bone_find_shared_parent(EditBone *ebone_child[], const unsigned int ebone_child_tot);
150
151 void ED_armature_ebone_to_mat3(EditBone *ebone, float mat[3][3]);
152 void ED_armature_ebone_to_mat4(EditBone *ebone, float mat[4][4]);
153
154 void ED_armature_ebone_from_mat3(EditBone *ebone, float mat[3][3]);
155 void ED_armature_ebone_from_mat4(EditBone *ebone, float mat[4][4]);
156
157 void transform_armature_mirror_update(struct Object *obedit);
158 void ED_armature_origin_set(struct Scene *scene, struct Object *ob, float cursor[3], int centermode, int around);
159
160 void ED_armature_transform_bones(struct bArmature *arm, float mat[4][4]);
161 void ED_armature_apply_transform(struct Object *ob, float mat[4][4]);
162 void ED_armature_transform(struct bArmature *arm, float mat[4][4]);
163
164 #define ARM_GROUPS_NAME     1
165 #define ARM_GROUPS_ENVELOPE 2
166 #define ARM_GROUPS_AUTO     3
167
168 void create_vgroups_from_armature(struct ReportList *reports, struct Scene *scene, struct Object *ob,
169                                   struct Object *par, const int mode, const bool mirror);
170
171 /* if bone is already in list, pass it as param to ignore it */
172 void unique_editbone_name(struct ListBase *ebones, char *name, EditBone *bone);
173 void ED_armature_bone_rename(struct bArmature *arm, const char *oldnamep, const char *newnamep);
174
175 void undo_push_armature(struct bContext *C, const char *name);
176
177 /* low level selection functions which handle */
178 int  ED_armature_ebone_selectflag_get(const EditBone *ebone);
179 void ED_armature_ebone_selectflag_set(EditBone *ebone, int flag);
180 void ED_armature_ebone_select_set(EditBone *ebone, bool select);
181 void ED_armature_ebone_selectflag_enable(EditBone *ebone, int flag);
182 void ED_armature_ebone_selectflag_disable(EditBone *ebone, int flag);
183
184 /* poseobject.c */
185 void ED_armature_exit_posemode(struct bContext *C, struct Base *base);
186 void ED_armature_enter_posemode(struct bContext *C, struct Base *base);
187 void ED_pose_de_selectall(struct Object *ob, int select_mode, const bool ignore_visibility);
188 void ED_pose_bone_select(struct Object *ob, struct bPoseChannel *pchan, bool select);
189 void ED_pose_recalculate_paths(struct Scene *scene, struct Object *ob);
190 struct Object *ED_pose_object_from_context(struct bContext *C);
191
192 /* sketch */
193
194 int ED_operator_sketch_mode_active_stroke(struct bContext *C);
195 int ED_operator_sketch_full_mode(struct bContext *C);
196 int ED_operator_sketch_mode(const struct bContext *C);
197
198 void BIF_convertSketch(struct bContext *C);
199 void BIF_deleteSketch(struct bContext *C);
200 void BIF_selectAllSketch(struct bContext *C, int mode); /* -1: deselect, 0: select, 1: toggle */
201
202 void  BIF_makeListTemplates(const struct bContext *C);
203 int   BIF_currentTemplate(const struct bContext *C);
204 void  BIF_freeTemplates(struct bContext *C);
205 void  BIF_setTemplate(struct bContext *C, int index);
206 int   BIF_nbJointsTemplate(const struct bContext *C);
207 const char *BIF_nameBoneTemplate(const struct bContext *C);
208
209 void BDR_drawSketch(const struct bContext *vc);
210 int BDR_drawSketchNames(struct ViewContext *vc);
211
212 /* meshlaplacian.c */
213 void mesh_deform_bind(struct Scene *scene,
214                       struct MeshDeformModifierData *mmd,
215                       struct DerivedMesh *cagedm,
216                       float *vertexcos, int totvert, float cagemat[4][4]);
217         
218 #ifdef __cplusplus
219 }
220 #endif
221
222 #endif /* __ED_ARMATURE_H__ */