doxygen: add newline after \file
[blender.git] / source / blender / collada / AnimationImporter.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup collada
19  */
20
21 #ifndef __ANIMATIONIMPORTER_H__
22 #define __ANIMATIONIMPORTER_H__
23
24 #include <map>
25 #include <vector>
26
27 #include "COLLADAFWAnimation.h"
28 #include "COLLADAFWAnimationCurve.h"
29 #include "COLLADAFWAnimationList.h"
30 #include "COLLADAFWNode.h"
31 #include "COLLADAFWUniqueId.h"
32 #include "COLLADAFWLight.h"
33 #include "COLLADAFWCamera.h"
34 #include "COLLADAFWMaterial.h"
35 #include "COLLADAFWEffect.h"
36 #include "COLLADAFWInstanceGeometry.h"
37
38 extern "C" {
39 #include "BKE_context.h"
40 #include "DNA_anim_types.h"
41 #include "DNA_object_types.h"
42 #include "DNA_scene_types.h"
43 #include "DNA_lamp_types.h"
44 #include "DNA_camera_types.h"
45 }
46
47 //#include "ArmatureImporter.h"
48 #include "TransformReader.h"
49
50 #include "collada_internal.h"
51
52 class ArmatureImporter;
53
54 class AnimationImporterBase
55 {
56 public:
57         // virtual void change_eul_to_quat(Object *ob, bAction *act) = 0;
58 };
59
60 class AnimationImporter : private TransformReader, public AnimationImporterBase
61 {
62 private:
63         bContext *mContext;
64         ArmatureImporter *armature_importer;
65         Scene *scene;
66
67         std::map<COLLADAFW::UniqueId, std::vector<FCurve*> > curve_map;
68         std::map<COLLADAFW::UniqueId, TransformReader::Animation> uid_animated_map;
69         // std::map<bActionGroup*, std::vector<FCurve*> > fcurves_actionGroup_map;
70         std::map<COLLADAFW::UniqueId, const COLLADAFW::AnimationList*> animlist_map;
71         std::vector<FCurve*> unused_curves;
72         std::map<COLLADAFW::UniqueId, Object*> joint_objects;
73
74         FCurve *create_fcurve(int array_index, const char *rna_path);
75
76         void add_bezt(FCurve *fcu, float frame, float value, eBezTriple_Interpolation ipo=BEZT_IPO_LIN);
77
78         // create one or several fcurves depending on the number of parameters being animated
79         void animation_to_fcurves(COLLADAFW::AnimationCurve *curve);
80
81         void fcurve_deg_to_rad(FCurve *cu);
82
83         void fcurve_is_used(FCurve *fcu);
84
85         void add_fcurves_to_object(Main *bmain, Object *ob, std::vector<FCurve*>& curves, char *rna_path, int array_index, Animation *animated);
86
87
88         int typeFlag;
89
90         std::string import_from_version;
91
92         enum lightAnim
93         {
94 //              INANIMATE = 0,
95                 LIGHT_COLOR     = 2,
96                 LIGHT_FOA = 4,
97                 LIGHT_FOE = 8,
98         };
99
100         enum cameraAnim
101         {
102 //              INANIMATE = 0,
103                 CAMERA_XFOV = 2,
104                 CAMERA_XMAG = 4,
105                 CAMERA_YFOV = 8,
106                 CAMERA_YMAG = 16,
107                 CAMERA_ZFAR = 32,
108                 CAMERA_ZNEAR = 64,
109         };
110
111         enum matAnim
112         {
113                 MATERIAL_SHININESS = 2,
114                 MATERIAL_SPEC_COLOR = 4,
115                 MATERIAL_DIFF_COLOR = 1 << 3,
116                 MATERIAL_TRANSPARENCY = 1 << 4,
117                 MATERIAL_IOR = 1 << 5,
118         };
119
120         enum AnimationType
121                 {
122                         BC_INANIMATE = 0,
123                         BC_NODE_TRANSFORM = 1,
124                 };
125
126         struct AnimMix
127         {
128                 int transform;
129                 int light;
130                 int camera;
131                 int material;
132                 int texture;
133         };
134 public:
135
136         AnimationImporter(bContext *C, UnitConverter *conv, ArmatureImporter *arm, Scene *scene) :
137                 TransformReader(conv),
138                 mContext(C),
139                 armature_importer(arm),
140                 scene(scene) {}
141
142         ~AnimationImporter();
143
144         void set_import_from_version(std::string import_from_version);
145         bool write_animation(const COLLADAFW::Animation* anim);
146
147         // called on post-process stage after writeVisualScenes
148         bool write_animation_list(const COLLADAFW::AnimationList* animlist);
149
150         void read_node_transform(COLLADAFW::Node *node, Object *ob);
151 #if 0
152         virtual void change_eul_to_quat(Object *ob, bAction *act);
153 #endif
154
155         void translate_Animations(COLLADAFW::Node * Node,
156                                   std::map<COLLADAFW::UniqueId, COLLADAFW::Node*>& root_map,
157                                   std::multimap<COLLADAFW::UniqueId, Object*>& object_map,
158                                   std::map<COLLADAFW::UniqueId, const COLLADAFW::Object*> FW_object_map,
159                                   std::map<COLLADAFW::UniqueId, Material*> uid_material_map);
160
161         AnimMix* get_animation_type( const COLLADAFW::Node * node, std::map<COLLADAFW::UniqueId, const COLLADAFW::Object*> FW_object_map );
162
163         void apply_matrix_curves(Object *ob, std::vector<FCurve*>& animcurves, COLLADAFW::Node* root, COLLADAFW::Node* node,
164                                  COLLADAFW::Transformation * tm );
165
166         void add_bone_animation_sampled(Object *ob, std::vector<FCurve*>& animcurves, COLLADAFW::Node* root, COLLADAFW::Node* node, COLLADAFW::Transformation * tm);
167
168         void Assign_transform_animations(COLLADAFW::Transformation* transform,
169                                          const COLLADAFW::AnimationList::AnimationBinding *binding,
170                                          std::vector<FCurve*>* curves, bool is_joint, char *joint_path);
171
172         void Assign_color_animations(const COLLADAFW::UniqueId& listid, ListBase *AnimCurves, const char * anim_type);
173         void Assign_float_animations(const COLLADAFW::UniqueId& listid, ListBase *AnimCurves, const char * anim_type);
174         void Assign_lens_animations(const COLLADAFW::UniqueId& listid, ListBase *AnimCurves, const double aspect, Camera *cam, const char *anim_type, int fov_type);
175
176         int setAnimType ( const COLLADAFW::Animatable * prop, int type, int addition);
177
178         void modify_fcurve(std::vector<FCurve*>* curves, const char *rna_path, int array_index );
179         void unused_fcurve(std::vector<FCurve*>* curves );
180         // prerequisites:
181         // animlist_map - map animlist id -> animlist
182         // curve_map - map anim id -> curve(s)
183         Object *translate_animation_OLD(COLLADAFW::Node *node,
184                 std::map<COLLADAFW::UniqueId, Object *>& object_map,
185                 std::map<COLLADAFW::UniqueId, COLLADAFW::Node *>& root_map,
186                 COLLADAFW::Transformation::TransformationType tm_type,
187                 Object *par_job = NULL);
188
189         void find_frames( std::vector<float>* frames, std::vector<FCurve*>* curves );
190         void find_frames_old( std::vector<float>* frames, COLLADAFW::Node * node, COLLADAFW::Transformation::TransformationType tm_type );
191         // internal, better make it private
192         // warning: evaluates only rotation
193         // prerequisites: animlist_map, curve_map
194         void evaluate_transform_at_frame(float mat[4][4], COLLADAFW::Node *node, float fra);
195
196         // return true to indicate that mat contains a sane value
197         bool evaluate_animation(COLLADAFW::Transformation *tm, float mat[4][4], float fra, const char *node_id);
198
199         // gives a world-space mat of joint at rest position
200         void get_joint_rest_mat(float mat[4][4], COLLADAFW::Node *root, COLLADAFW::Node *node);
201
202         // gives a world-space mat, end's mat not included
203         bool calc_joint_parent_mat_rest(float mat[4][4], float par[4][4], COLLADAFW::Node *node, COLLADAFW::Node *end);
204
205         float convert_to_focal_length(float in_xfov, int fov_type, float aspect, float sensorx);
206
207 #ifdef ARMATURE_TEST
208         Object *get_joint_object(COLLADAFW::Node *root, COLLADAFW::Node *node, Object *par_job);
209 #endif
210
211 #if 0
212         // recursively evaluates joint tree until end is found, mat then is world-space matrix of end
213         // mat must be identity on enter, node must be root
214         bool evaluate_joint_world_transform_at_frame(float mat[4][4], float par[4][4], COLLADAFW::Node *node, COLLADAFW::Node *end, float fra);
215 #endif
216
217         void add_bone_fcurve(Object *ob, COLLADAFW::Node *node, FCurve *fcu);
218
219         void extra_data_importer(std::string elementName);
220 };
221
222 #endif