Fixed Camera Ortho scale animation import
[blender-staging.git] / source / blender / collada / AnimationImporter.h
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * Contributor(s): Chingiz Dyussenov, Arystanbek Dyussenov, Nathan Letwory.
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24  
25 /** \file AnimationImporter.h
26  *  \ingroup collada
27  */
28
29 #ifndef __BC_ANIMATIONIMPORTER_H__
30 #define __BC_ANIMATIONIMPORTER_H__
31
32 #include <map>
33 #include <vector>
34
35 #include "COLLADAFWAnimation.h"
36 #include "COLLADAFWAnimationCurve.h"
37 #include "COLLADAFWAnimationList.h"
38 #include "COLLADAFWNode.h"
39 #include "COLLADAFWUniqueId.h"
40 #include "COLLADAFWLight.h"
41 #include "COLLADAFWCamera.h"
42
43 #include "DNA_anim_types.h"
44 #include "DNA_object_types.h"
45 #include "DNA_scene_types.h"
46 #include "DNA_lamp_types.h"
47 #include "DNA_camera_types.h"
48
49 //#include "ArmatureImporter.h"
50 #include "TransformReader.h"
51
52 #include "collada_internal.h"
53
54 class ArmatureImporter;
55
56 class AnimationImporterBase
57 {
58 public:
59         // virtual void change_eul_to_quat(Object *ob, bAction *act) = 0;
60 };
61
62 class AnimationImporter : private TransformReader, public AnimationImporterBase
63 {
64 private:
65
66         ArmatureImporter *armature_importer;
67         Scene *scene;
68
69         std::map<COLLADAFW::UniqueId, std::vector<FCurve*> > curve_map;
70         std::map<COLLADAFW::UniqueId, TransformReader::Animation> uid_animated_map;
71         // std::map<bActionGroup*, std::vector<FCurve*> > fcurves_actionGroup_map;
72         std::map<COLLADAFW::UniqueId, const COLLADAFW::AnimationList*> animlist_map;
73         std::vector<FCurve*> unused_curves;
74         std::map<COLLADAFW::UniqueId, Object*> joint_objects;
75         
76         FCurve *create_fcurve(int array_index, const char *rna_path);
77         
78         void create_bezt(FCurve *fcu, float frame, float output);
79
80         // create one or several fcurves depending on the number of parameters being animated
81         void animation_to_fcurves(COLLADAFW::AnimationCurve *curve);
82
83         void fcurve_deg_to_rad(FCurve *cu);
84
85         void add_fcurves_to_object(Object *ob, std::vector<FCurve*>& curves, char *rna_path, int array_index, Animation *animated);
86         
87         int typeFlag;
88
89         enum AnimationType
90                 {
91                         INANIMATE = 0,
92                         NODE_TRANSFORM = 1,
93                         LIGHT_COLOR     = 2,
94                         LIGHT_FOA = 4,
95                         LIGHT_FOE = 8,
96                         CAMERA_XFOV = 16,
97                         CAMERA_XMAG = 32
98                 };
99 public:
100
101         AnimationImporter(UnitConverter *conv, ArmatureImporter *arm, Scene *scene);
102
103         ~AnimationImporter();
104
105         bool write_animation(const COLLADAFW::Animation* anim);
106         
107         // called on post-process stage after writeVisualScenes
108         bool write_animation_list(const COLLADAFW::AnimationList* animlist);
109
110         void read_node_transform(COLLADAFW::Node *node, Object *ob);
111 #if 0
112         virtual void change_eul_to_quat(Object *ob, bAction *act);
113 #endif
114   
115         void translate_Animations_NEW ( COLLADAFW::Node * Node , 
116                                                                                                    std::map<COLLADAFW::UniqueId, COLLADAFW::Node*>& root_map,
117                                                                                                    std::map<COLLADAFW::UniqueId, Object*>& object_map ,
118                                                                                                    std::map<COLLADAFW::UniqueId, const COLLADAFW::Object*> FW_object_map);
119
120         int get_animation_type( const COLLADAFW::Node * node , std::map<COLLADAFW::UniqueId,const COLLADAFW::Object*> FW_object_map ) ;
121
122
123         void Assign_transform_animations(COLLADAFW::Transformation* transform , 
124                                                                          const COLLADAFW::AnimationList::AnimationBinding * binding,
125                                                                          std::vector<FCurve*>* curves, bool is_joint, char * joint_path);
126
127         void Assign_color_animations(const COLLADAFW::AnimationList::AnimationBinding * binding,
128                                                                  std::vector<FCurve*>* curves);
129
130         void Assign_float_animations(const COLLADAFW::UniqueId& listid, ListBase *AnimCurves, char * anim_type);
131
132         void modify_fcurve(std::vector<FCurve*>* curves , char* rna_path , int array_index );
133         // prerequisites:
134         // animlist_map - map animlist id -> animlist
135         // curve_map - map anim id -> curve(s)
136         Object * translate_animation(COLLADAFW::Node *node,
137                                                                 std::map<COLLADAFW::UniqueId, Object*>& object_map,
138                                                                 std::map<COLLADAFW::UniqueId, COLLADAFW::Node*>& root_map,
139                                                                 COLLADAFW::Transformation::TransformationType tm_type,
140                                                                 Object *par_job = NULL);
141         
142         void find_frames( std::vector<float>* frames , std::vector<FCurve*>* curves );
143         void find_frames_old( std::vector<float>* frames, COLLADAFW::Node * node, COLLADAFW::Transformation::TransformationType tm_type );
144         // internal, better make it private
145         // warning: evaluates only rotation
146         // prerequisites: animlist_map, curve_map
147         void evaluate_transform_at_frame(float mat[4][4], COLLADAFW::Node *node, float fra);
148
149         // return true to indicate that mat contains a sane value
150         bool evaluate_animation(COLLADAFW::Transformation *tm, float mat[4][4], float fra, const char *node_id);
151
152         // gives a world-space mat of joint at rest position
153         void get_joint_rest_mat(float mat[4][4], COLLADAFW::Node *root, COLLADAFW::Node *node);
154
155         // gives a world-space mat, end's mat not included
156         bool calc_joint_parent_mat_rest(float mat[4][4], float par[4][4], COLLADAFW::Node *node, COLLADAFW::Node *end);
157
158 #ifdef ARMATURE_TEST
159         Object *get_joint_object(COLLADAFW::Node *root, COLLADAFW::Node *node, Object *par_job);
160 #endif
161
162 #if 0
163         // recursively evaluates joint tree until end is found, mat then is world-space matrix of end
164         // mat must be identity on enter, node must be root
165         bool evaluate_joint_world_transform_at_frame(float mat[4][4], float par[4][4], COLLADAFW::Node *node, COLLADAFW::Node *end, float fra);
166 #endif
167
168         void add_bone_fcurve(Object *ob, COLLADAFW::Node *node, FCurve *fcu);
169
170         void add_bezt(FCurve *fcu, float fra, float value);
171 };
172  
173  #endif