Cleanup: manually remove header text not handled by automation
[blender.git] / source / blender / collada / BCAnimationSampler.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 #ifndef __BC_ANIMATION_CURVE_CONTAINER_H__
18 #define __BC_ANIMATION_CURVE_CONTAINER_H__
19
20 #include "BCAnimationCurve.h"
21 #include "BCSampleData.h"
22 #include "collada_utils.h"
23
24 extern "C" {
25 #include "BKE_action.h"
26 #include "BKE_library.h"
27 #include "BLI_math_rotation.h"
28 #include "DNA_action_types.h"
29 }
30
31 /* Collection of animation curves */
32 class BCAnimation {
33 private:
34         Object *reference = NULL;
35         bContext *mContext;
36
37
38 public:
39         BCFrameSet frame_set;
40         BCAnimationCurveMap curve_map;
41
42         BCAnimation(bContext *C, Object *ob):
43                 mContext(C)
44         {
45                 Main *bmain = CTX_data_main(mContext);
46                 reference = BKE_object_copy(bmain, ob);
47         }
48
49         ~BCAnimation()
50         {
51                 BCAnimationCurveMap::iterator it;
52                 for (it = curve_map.begin(); it != curve_map.end(); ++it) {
53                         delete it->second;
54                 }
55
56                 if (reference && reference->id.us == 0)
57                 {
58                         Main *bmain = CTX_data_main(mContext);
59                         BKE_id_delete(bmain, &reference->id);
60                 }
61                 curve_map.clear();
62         }
63
64         Object *get_reference()
65         {
66                 return reference;
67         }
68 };
69
70 typedef std::map<Object *, BCAnimation *> BCAnimationObjectMap;
71
72 class BCSampleFrame {
73
74         /*
75         Each frame on the timeline that needs to be sampled will have
76         one BCSampleFrame where we collect sample information about all objects
77         that need to be sampled for that frame.
78         */
79
80 private:
81         BCSampleMap sampleMap;
82
83 public:
84
85         ~BCSampleFrame()
86         {
87                 BCSampleMap::iterator it;
88                 for (it = sampleMap.begin(); it != sampleMap.end(); ++it) {
89                         BCSample *sample = it->second;
90                         delete sample;
91                 }
92                 sampleMap.clear();
93         }
94
95         BCSample &add(Object *ob);
96
97         /* Following methods return NULL if object is not in the sampleMap*/
98         const BCSample *get_sample(Object *ob) const;
99         const BCMatrix *get_sample_matrix(Object *ob) const;
100         const BCMatrix *get_sample_matrix(Object *ob, Bone *bone) const;
101
102         const bool has_sample_for(Object *ob) const;
103         const bool has_sample_for(Object *ob, Bone *bone) const;
104 };
105
106 typedef std::map<int, BCSampleFrame> BCSampleFrameMap;
107
108 class BCSampleFrameContainer {
109
110         /*
111         * The BCSampleFrameContainer stores a map of BCSampleFrame objects
112         * with the timeline frame as key.
113         *
114         * Some details on the purpose:
115         * An Animation is made of multiple FCurves where each FCurve can
116         * have multiple keyframes. When we want to export the animation we
117         * also can decide whether we want to export the keyframes or a set
118         * of sample frames at equidistant locations (sample period).
119         * In any case we must resample first need to resample it fully
120         * to resolve things like:
121         *
122         * - animations by constraints
123         * - animations by drivers
124         *
125         * For this purpose we need to step through the entire animation and
126         * then sample each frame that contains at least one keyFrame or
127         * sampleFrame. Then for each frame we have to store the transform
128         * information for all exported objects in a BCSampleframe
129         *
130         * The entire set of BCSampleframes is finally collected into
131         * a BCSampleframneContainer
132         */
133
134 private:
135         BCSampleFrameMap sample_frames;
136
137 public:
138
139         ~BCSampleFrameContainer()
140         {
141         }
142
143         BCSample &add(Object *ob, int frame_index);
144         BCSampleFrame *get_frame(int frame_index); // returns NULL if frame does not exist
145
146         const int get_frames(std::vector<int> &frames) const;
147         const int get_frames(Object *ob, BCFrames &frames) const;
148         const int get_frames(Object *ob, Bone *bone, BCFrames &frames) const;
149
150         const int get_samples(Object *ob, BCFrameSampleMap &samples) const;
151         const int get_matrices(Object *ob, BCMatrixSampleMap &matrices) const;
152         const int get_matrices(Object *ob, Bone *bone, BCMatrixSampleMap &bones) const;
153 };
154
155 class BCAnimationSampler {
156 private:
157         BlenderContext &blender_context;
158         BCSampleFrameContainer sample_data;
159         BCAnimationObjectMap objects;
160
161         void generate_transform(Object *ob, const BCCurveKey &key, BCAnimationCurveMap &curves);
162         void generate_transforms(Object *ob, const std::string prep, const BC_animation_type type, BCAnimationCurveMap &curves);
163         void generate_transforms(Object *ob, Bone *bone, BCAnimationCurveMap &curves);
164
165         void initialize_curves(BCAnimationCurveMap &curves, Object *ob);
166         void initialize_keyframes(BCFrameSet &frameset, Object *ob);
167         BCSample &sample_object(Object *ob, int frame_index, bool for_opensim);
168         void update_animation_curves(BCAnimation &animation, BCSample &sample, Object *ob, int frame_index);
169         void check_property_is_animated(BCAnimation &animation, float *ref, float *val, std::string data_path, int length);
170
171 public:
172         BCAnimationSampler(BlenderContext &blender_context, BCObjectSet &animated_subset);
173         ~BCAnimationSampler();
174
175         void add_object(Object *ob);
176
177         void sample_scene(
178                 int sampling_rate,
179                 int keyframe_at_end,
180                 bool for_opensim,
181                 bool keep_keyframes,
182                 BC_export_animation_type export_animation_type);
183
184         BCAnimationCurveMap *get_curves(Object *ob);
185         void get_object_frames(BCFrames &frames, Object *ob);
186         bool get_object_samples(BCMatrixSampleMap &samples, Object *ob);
187         void get_bone_frames(BCFrames &frames, Object *ob, Bone *bone);
188         bool get_bone_samples(BCMatrixSampleMap &samples, Object *ob, Bone *bone);
189
190         static void get_animated_from_export_set(std::set<Object *> &animated_objects, LinkNode &export_set);
191         static void find_depending_animated(std::set<Object *> &animated_objects, std::set<Object *> &candidates);
192         static bool is_animated_by_constraint(Object *ob, ListBase *conlist, std::set<Object *> &animated_objects);
193
194 };
195
196 #endif