Fix #29295: Problem with Alpha Channel video in Sequencer and textures
[blender-staging.git] / source / blender / collada / SkinInfo.cpp
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.
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/collada/SkinInfo.cpp
24  *  \ingroup collada
25  */
26
27
28 #include <algorithm>
29
30 #if !defined(WIN32) || defined(FREE_WINDOWS)
31 #include <stdint.h>
32 #endif
33
34 /* COLLADABU_ASSERT, may be able to remove later */
35 #include "COLLADABUPlatform.h"
36
37 #include "BKE_object.h"
38 #include "DNA_armature_types.h"
39 #include "DNA_modifier_types.h"
40 #include "ED_mesh.h"
41 #include "ED_object.h"
42 #include "BKE_action.h"
43 #include "BLI_listbase.h"
44 #include "BLI_math.h"
45
46 #include "SkinInfo.h"
47 #include "collada_utils.h"
48
49 // use name, or fall back to original id if name not present (name is optional)
50 template<class T>
51 static const char *bc_get_joint_name(T *node)
52 {
53         const std::string& id = node->getName();
54         return id.size() ? id.c_str() : node->getOriginalId().c_str();
55 }
56
57 // This is used to store data passed in write_controller_data.
58 // Arrays from COLLADAFW::SkinControllerData lose ownership, so do this class members
59 // so that arrays don't get freed until we free them explicitly.
60 SkinInfo::SkinInfo() {}
61
62 SkinInfo::SkinInfo(const SkinInfo& skin) : weights(skin.weights),
63                                                                  joint_data(skin.joint_data),
64                                                                  unit_converter(skin.unit_converter),
65                                                                  ob_arm(skin.ob_arm),
66                                                                  controller_uid(skin.controller_uid),
67                                                                  parent(skin.parent)
68 {
69         copy_m4_m4(bind_shape_matrix, (float (*)[4])skin.bind_shape_matrix);
70
71         transfer_uint_array_data_const(skin.joints_per_vertex, joints_per_vertex);
72         transfer_uint_array_data_const(skin.weight_indices, weight_indices);
73         transfer_int_array_data_const(skin.joint_indices, joint_indices);
74 }
75
76 SkinInfo::SkinInfo(UnitConverter *conv) : unit_converter(conv), ob_arm(NULL), parent(NULL) {}
77
78 // nobody owns the data after this, so it should be freed manually with releaseMemory
79 template <class T>
80 void SkinInfo::transfer_array_data(T& src, T& dest)
81 {
82         dest.setData(src.getData(), src.getCount());
83         src.yieldOwnerShip();
84         dest.yieldOwnerShip();
85 }
86
87 // when src is const we cannot src.yieldOwnerShip, this is used by copy constructor
88 void SkinInfo::transfer_int_array_data_const(const COLLADAFW::IntValuesArray& src, COLLADAFW::IntValuesArray& dest)
89 {
90         dest.setData((int*)src.getData(), src.getCount());
91         dest.yieldOwnerShip();
92 }
93
94 void SkinInfo::transfer_uint_array_data_const(const COLLADAFW::UIntValuesArray& src, COLLADAFW::UIntValuesArray& dest)
95 {
96         dest.setData((unsigned int*)src.getData(), src.getCount());
97         dest.yieldOwnerShip();
98 }
99
100 void SkinInfo::borrow_skin_controller_data(const COLLADAFW::SkinControllerData* skin)
101 {
102         transfer_array_data((COLLADAFW::UIntValuesArray&)skin->getJointsPerVertex(), joints_per_vertex);
103         transfer_array_data((COLLADAFW::UIntValuesArray&)skin->getWeightIndices(), weight_indices);
104         transfer_array_data((COLLADAFW::IntValuesArray&)skin->getJointIndices(), joint_indices);
105         // transfer_array_data(skin->getWeights(), weights);
106
107         // cannot transfer data for FloatOrDoubleArray, copy values manually
108         const COLLADAFW::FloatOrDoubleArray& weight = skin->getWeights();
109         for (unsigned int i = 0; i < weight.getValuesCount(); i++)
110                 weights.push_back(bc_get_float_value(weight, i));
111
112         unit_converter->dae_matrix_to_mat4_(bind_shape_matrix, skin->getBindShapeMatrix());
113 }
114         
115 void SkinInfo::free()
116 {
117         joints_per_vertex.releaseMemory();
118         weight_indices.releaseMemory();
119         joint_indices.releaseMemory();
120         // weights.releaseMemory();
121 }
122
123 // using inverse bind matrices to construct armature
124 // it is safe to invert them to get the original matrices
125 // because if they are inverse matrices, they can be inverted
126 void SkinInfo::add_joint(const COLLADABU::Math::Matrix4& matrix)
127 {
128         JointData jd;
129         unit_converter->dae_matrix_to_mat4_(jd.inv_bind_mat, matrix);
130         joint_data.push_back(jd);
131 }
132
133 void SkinInfo::set_controller(const COLLADAFW::SkinController* co)
134 {
135         controller_uid = co->getUniqueId();
136
137         // fill in joint UIDs
138         const COLLADAFW::UniqueIdArray& joint_uids = co->getJoints();
139         for (unsigned int i = 0; i < joint_uids.getCount(); i++) {
140                 joint_data[i].joint_uid = joint_uids[i];
141
142                 // // store armature pointer
143                 // JointData& jd = joint_index_to_joint_info_map[i];
144                 // jd.ob_arm = ob_arm;
145
146                 // now we'll be able to get inv bind matrix from joint id
147                 // joint_id_to_joint_index_map[joint_ids[i]] = i;
148         }
149 }
150
151 // called from write_controller
152 Object *SkinInfo::create_armature(Scene *scene)
153 {
154         ob_arm = add_object(scene, OB_ARMATURE);
155         return ob_arm;
156 }
157
158 Object* SkinInfo::set_armature(Object *ob_arm)
159 {
160         if (this->ob_arm)
161                 return this->ob_arm;
162
163         this->ob_arm = ob_arm;
164         return ob_arm;
165 }
166
167 bool SkinInfo::get_joint_inv_bind_matrix(float inv_bind_mat[][4], COLLADAFW::Node *node)
168 {
169         const COLLADAFW::UniqueId& uid = node->getUniqueId();
170         std::vector<JointData>::iterator it;
171         for (it = joint_data.begin(); it != joint_data.end(); it++) {
172                 if ((*it).joint_uid == uid) {
173                         copy_m4_m4(inv_bind_mat, (*it).inv_bind_mat);
174                         return true;
175                 }
176         }
177
178         return false;
179 }
180
181 Object *SkinInfo::get_armature()
182 {
183         return ob_arm;
184 }
185
186 const COLLADAFW::UniqueId& SkinInfo::get_controller_uid()
187 {
188         return controller_uid;
189 }
190
191 // check if this skin controller references a joint or any descendant of it
192 // 
193 // some nodes may not be referenced by SkinController,
194 // in this case to determine if the node belongs to this armature,
195 // we need to search down the tree
196 bool SkinInfo::uses_joint_or_descendant(COLLADAFW::Node *node)
197 {
198         const COLLADAFW::UniqueId& uid = node->getUniqueId();
199         std::vector<JointData>::iterator it;
200         for (it = joint_data.begin(); it != joint_data.end(); it++) {
201                 if ((*it).joint_uid == uid)
202                         return true;
203         }
204
205         COLLADAFW::NodePointerArray& children = node->getChildNodes();
206         for (unsigned int i = 0; i < children.getCount(); i++) {
207                 if (uses_joint_or_descendant(children[i]))
208                         return true;
209         }
210
211         return false;
212 }
213
214 void SkinInfo::link_armature(bContext *C, Object *ob, std::map<COLLADAFW::UniqueId, COLLADAFW::Node*>& joint_by_uid,
215                                    TransformReader *tm)
216 {
217         Main *bmain = CTX_data_main(C);
218         Scene *scene = CTX_data_scene(C);
219
220         ModifierData *md = ED_object_modifier_add(NULL, bmain, scene, ob, NULL, eModifierType_Armature);
221         ((ArmatureModifierData *)md)->object = ob_arm;
222
223         copy_m4_m4(ob->obmat, bind_shape_matrix);
224         object_apply_mat4(ob, ob->obmat, 0, 0);
225 #if 1
226         bc_set_parent(ob, ob_arm, C);
227 #else
228         Object workob;
229         ob->parent = ob_arm;
230         ob->partype = PAROBJECT;
231
232         what_does_parent(scene, ob, &workob);
233         invert_m4_m4(ob->parentinv, workob.obmat);
234
235         ob->recalc |= OB_RECALC_OB|OB_RECALC_DATA;
236
237         DAG_scene_sort(bmain, scene);
238         DAG_ids_flush_update(bmain, 0);
239         WM_event_add_notifier(C, NC_OBJECT|ND_TRANSFORM, NULL);
240 #endif
241
242         ((bArmature*)ob_arm->data)->deformflag = ARM_DEF_VGROUP;
243
244         // create all vertex groups
245         std::vector<JointData>::iterator it;
246         int joint_index;
247         for (it = joint_data.begin(), joint_index = 0; it != joint_data.end(); it++, joint_index++) {
248                 const char *name = "Group";
249
250                 // skip joints that have invalid UID
251                 if ((*it).joint_uid == COLLADAFW::UniqueId::INVALID) continue;
252                 
253                 // name group by joint node name
254                 
255                 if (joint_by_uid.find((*it).joint_uid) != joint_by_uid.end()) {
256                         name = bc_get_joint_name(joint_by_uid[(*it).joint_uid]);
257                 }
258
259                 ED_vgroup_add_name(ob, (char*)name);
260         }
261
262         // <vcount> - number of joints per vertex - joints_per_vertex
263         // <v> - [[bone index, weight index] * joints per vertex] * vertices - weight indices
264         // ^ bone index can be -1 meaning weight toward bind shape, how to express this in Blender?
265
266         // for each vertex in weight indices
267         //      for each bone index in vertex
268         //              add vertex to group at group index
269         //              treat group index -1 specially
270
271         // get def group by index with BLI_findlink
272
273         for (unsigned int vertex = 0, weight = 0; vertex < joints_per_vertex.getCount(); vertex++) {
274
275                 unsigned int limit = weight + joints_per_vertex[vertex];
276                 for ( ; weight < limit; weight++) {
277                         int joint = joint_indices[weight], joint_weight = weight_indices[weight];
278
279                         // -1 means "weight towards the bind shape", we just don't assign it to any group
280                         if (joint != -1) {
281                                 bDeformGroup *def = (bDeformGroup*)BLI_findlink(&ob->defbase, joint);
282
283                                 ED_vgroup_vert_add(ob, def, vertex, weights[joint_weight], WEIGHT_REPLACE);
284                         }
285                 }
286         }
287 }
288
289 bPoseChannel *SkinInfo::get_pose_channel_from_node(COLLADAFW::Node *node)
290 {
291         return get_pose_channel(ob_arm->pose, bc_get_joint_name(node));
292 }
293
294 void SkinInfo::set_parent(Object *_parent)
295 {
296         parent = _parent;
297 }
298
299 Object* SkinInfo::get_parent()
300 {
301         return parent;
302 }
303
304 void SkinInfo::find_root_joints(const std::vector<COLLADAFW::Node*> &root_joints,
305                                           std::map<COLLADAFW::UniqueId, COLLADAFW::Node*>& joint_by_uid,
306                                           std::vector<COLLADAFW::Node*>& result)
307 {
308         std::vector<COLLADAFW::Node*>::const_iterator it;
309         // for each root_joint
310         for (it = root_joints.begin(); it != root_joints.end(); it++) {
311                 COLLADAFW::Node *root = *it;
312                 std::vector<JointData>::iterator ji;
313                 //for each joint_data in this skin
314                 for (ji = joint_data.begin(); ji != joint_data.end(); ji++) {
315                         //get joint node from joint map
316                         COLLADAFW::Node *joint = joint_by_uid[(*ji).joint_uid];
317                         //find if joint node is in the tree belonging to the root_joint
318                         if (find_node_in_tree(joint, root)) {
319                                 if (std::find(result.begin(), result.end(), root) == result.end())
320                                         result.push_back(root);
321                         }
322                 }
323         }
324 }
325
326 bool SkinInfo::find_node_in_tree(COLLADAFW::Node *node, COLLADAFW::Node *tree_root)
327 {
328         if (node == tree_root)
329                 return true;
330
331         COLLADAFW::NodePointerArray& children = tree_root->getChildNodes();
332         for (unsigned int i = 0; i < children.getCount(); i++) {
333                 if (find_node_in_tree(node, children[i]))
334                         return true;
335         }
336
337         return false;
338 }