svn merge ^/trunk/blender -r46330:46335
[blender.git] / source / blender / collada / AnimationImporter.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  * Contributor(s): Chingiz Dyussenov, Arystanbek Dyussenov, Nathan Letwory, Sukhitha Jayathilake.
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22  
23 /** \file AnimationImporter.h
24  *  \ingroup collada
25  */
26
27 #ifndef __ANIMATIONIMPORTER_H__
28 #define __ANIMATIONIMPORTER_H__
29
30 #include <map>
31 #include <vector>
32
33 #include "COLLADAFWAnimation.h"
34 #include "COLLADAFWAnimationCurve.h"
35 #include "COLLADAFWAnimationList.h"
36 #include "COLLADAFWNode.h"
37 #include "COLLADAFWUniqueId.h"
38 #include "COLLADAFWLight.h"
39 #include "COLLADAFWCamera.h"
40 #include "COLLADAFWMaterial.h"
41 #include "COLLADAFWEffect.h"
42 #include "COLLADAFWInstanceGeometry.h"
43
44 #include "DNA_anim_types.h"
45 #include "DNA_object_types.h"
46 #include "DNA_scene_types.h"
47 #include "DNA_lamp_types.h"
48 #include "DNA_camera_types.h"
49
50 //#include "ArmatureImporter.h"
51 #include "TransformReader.h"
52
53 #include "collada_internal.h"
54
55 class ArmatureImporter;
56
57 class AnimationImporterBase
58 {
59 public:
60         // virtual void change_eul_to_quat(Object *ob, bAction *act) = 0;
61 };
62
63 class AnimationImporter : private TransformReader, public AnimationImporterBase
64 {
65 private:
66
67         ArmatureImporter *armature_importer;
68         Scene *scene;
69
70         std::map<COLLADAFW::UniqueId, std::vector<FCurve*> > curve_map;
71         std::map<COLLADAFW::UniqueId, TransformReader::Animation> uid_animated_map;
72         // std::map<bActionGroup*, std::vector<FCurve*> > fcurves_actionGroup_map;
73         std::map<COLLADAFW::UniqueId, const COLLADAFW::AnimationList*> animlist_map;
74         std::vector<FCurve*> unused_curves;
75         std::map<COLLADAFW::UniqueId, Object*> joint_objects;
76         
77         FCurve *create_fcurve(int array_index, const char *rna_path);
78         
79         void create_bezt(FCurve *fcu, float frame, float output);
80
81         // create one or several fcurves depending on the number of parameters being animated
82         void animation_to_fcurves(COLLADAFW::AnimationCurve *curve);
83
84         void fcurve_deg_to_rad(FCurve *cu);
85
86         void add_fcurves_to_object(Object *ob, std::vector<FCurve*>& curves, char *rna_path, int array_index, Animation *animated);
87         
88         int typeFlag;
89
90         enum lightAnim
91         {
92 //              INANIMATE = 0,
93                 LIGHT_COLOR     = 2,
94                 LIGHT_FOA = 4,
95                 LIGHT_FOE = 8
96         };
97
98         enum cameraAnim
99         {
100 //              INANIMATE = 0,
101                 CAMERA_XFOV = 2,
102                 CAMERA_XMAG = 4,
103                 CAMERA_ZFAR = 8,
104                 CAMERA_ZNEAR = 16
105         };
106
107         enum matAnim
108         {
109                 MATERIAL_SHININESS = 2,
110                 MATERIAL_SPEC_COLOR = 4,
111                 MATERIAL_DIFF_COLOR = 1 << 3,
112                 MATERIAL_TRANSPARENCY = 1 << 4,
113                 MATERIAL_IOR = 1 << 5
114         };
115         
116         enum AnimationType
117                 {
118                         INANIMATE = 0,
119                         NODE_TRANSFORM = 1,
120                 };
121
122         struct AnimMix
123         {
124                 int transform;
125                 int light;
126                 int camera;
127                 int material;
128                 int texture;
129         };
130 public:
131
132         AnimationImporter(UnitConverter *conv, ArmatureImporter *arm, Scene *scene);
133
134         ~AnimationImporter();
135
136         bool write_animation(const COLLADAFW::Animation* anim);
137         
138         // called on post-process stage after writeVisualScenes
139         bool write_animation_list(const COLLADAFW::AnimationList* animlist);
140
141         void read_node_transform(COLLADAFW::Node *node, Object *ob);
142 #if 0
143         virtual void change_eul_to_quat(Object *ob, bAction *act);
144 #endif
145
146         void translate_Animations(COLLADAFW::Node * Node,
147                                                           std::map<COLLADAFW::UniqueId, COLLADAFW::Node*>& root_map,
148                                                           std::multimap<COLLADAFW::UniqueId, Object*>& object_map,
149                                                           std::map<COLLADAFW::UniqueId, const COLLADAFW::Object*> FW_object_map);
150
151         AnimMix* get_animation_type( const COLLADAFW::Node * node, std::map<COLLADAFW::UniqueId, const COLLADAFW::Object*> FW_object_map );
152
153         void apply_matrix_curves(Object * ob, std::vector<FCurve*>& animcurves, COLLADAFW::Node* root, COLLADAFW::Node* node,
154                                  COLLADAFW::Transformation * tm );
155         
156         void add_bone_animation_sampled(Object * ob, std::vector<FCurve*>& animcurves, COLLADAFW::Node* root, COLLADAFW::Node* node, COLLADAFW::Transformation * tm);
157
158         void Assign_transform_animations(COLLADAFW::Transformation* transform,
159                                          const COLLADAFW::AnimationList::AnimationBinding * binding,
160                                          std::vector<FCurve*>* curves, bool is_joint, char * joint_path);
161
162         void Assign_color_animations(const COLLADAFW::UniqueId& listid, ListBase *AnimCurves, const char * anim_type);
163         void Assign_float_animations(const COLLADAFW::UniqueId& listid, ListBase *AnimCurves, const char * anim_type);
164
165         int setAnimType ( const COLLADAFW::Animatable * prop, int type, int addition);
166         
167         void modify_fcurve(std::vector<FCurve*>* curves, const char* rna_path, int array_index );
168         // prerequisites:
169         // animlist_map - map animlist id -> animlist
170         // curve_map - map anim id -> curve(s)
171         Object * translate_animation_OLD(COLLADAFW::Node *node,
172                                          std::map<COLLADAFW::UniqueId, Object*>& object_map,
173                                          std::map<COLLADAFW::UniqueId, COLLADAFW::Node*>& root_map,
174                                          COLLADAFW::Transformation::TransformationType tm_type,
175                                          Object *par_job = NULL);
176         
177         void find_frames( std::vector<float>* frames, std::vector<FCurve*>* curves );
178         void find_frames_old( std::vector<float>* frames, COLLADAFW::Node * node, COLLADAFW::Transformation::TransformationType tm_type );
179         // internal, better make it private
180         // warning: evaluates only rotation
181         // prerequisites: animlist_map, curve_map
182         void evaluate_transform_at_frame(float mat[4][4], COLLADAFW::Node *node, float fra);
183
184         // return true to indicate that mat contains a sane value
185         bool evaluate_animation(COLLADAFW::Transformation *tm, float mat[4][4], float fra, const char *node_id);
186
187         // gives a world-space mat of joint at rest position
188         void get_joint_rest_mat(float mat[4][4], COLLADAFW::Node *root, COLLADAFW::Node *node);
189
190         // gives a world-space mat, end's mat not included
191         bool calc_joint_parent_mat_rest(float mat[4][4], float par[4][4], COLLADAFW::Node *node, COLLADAFW::Node *end);
192
193 #ifdef ARMATURE_TEST
194         Object *get_joint_object(COLLADAFW::Node *root, COLLADAFW::Node *node, Object *par_job);
195 #endif
196
197 #if 0
198         // recursively evaluates joint tree until end is found, mat then is world-space matrix of end
199         // mat must be identity on enter, node must be root
200         bool evaluate_joint_world_transform_at_frame(float mat[4][4], float par[4][4], COLLADAFW::Node *node, COLLADAFW::Node *end, float fra);
201 #endif
202
203         void add_bone_fcurve(Object *ob, COLLADAFW::Node *node, FCurve *fcu);
204
205         void add_bezt(FCurve *fcu, float fra, float value);
206
207         void extra_data_importer(std::string elementName);
208 };
209
210 #endif