Collada exporter update
[blender.git] / source / blender / collada / TransformWriter.cpp
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 #include "BLI_math.h"
22 #include "BLI_sys_types.h"
23
24 #include "BKE_object.h"
25
26 #include "TransformWriter.h"
27
28 void TransformWriter::add_node_transform(COLLADASW::Node &node,
29                                          float mat[4][4],
30                                          float parent_mat[4][4],
31                                          BCExportSettings &export_settings
32         )
33 {
34   // bool limit_precision = export_settings.limit_precision;
35   float loc[3], rot[3], scale[3];
36   float local[4][4];
37
38   if (parent_mat) {
39     float invpar[4][4];
40     invert_m4_m4(invpar, parent_mat);
41     mul_m4_m4m4(local, invpar, mat);
42   }
43   else {
44     copy_m4_m4(local, mat);
45   }
46
47   if (export_settings.get_apply_global_orientation()) {
48     bc_apply_global_transform(local, export_settings.get_global_transform());
49   }
50
51   double dmat[4][4];
52   UnitConverter *converter = new UnitConverter();
53   converter->mat4_to_dae_double(dmat, local);
54   delete converter;
55
56   if (node.getType() == COLLADASW::Node::JOINT) {
57     // XXX Why are joints handled differently ?
58         // GC: I believe this is a mistake. Here we might want to 
59         // export according to how the transformation type
60         // is set, see add_node_transform_ob()
61     node.addMatrix("transform", dmat);
62   }
63   else {
64     bc_decompose(local, loc, rot, NULL, scale);
65     add_transform(node, loc, rot, scale);
66   }
67 }
68
69 void TransformWriter::add_node_transform_ob(COLLADASW::Node &node,
70                                             Object *ob,
71                                             BCExportSettings &export_settings)
72 {
73   BC_export_transformation_type transformation_type =
74       export_settings.get_export_transformation_type();
75   bool limit_precision = export_settings.get_limit_precision();
76
77   /* Export the local Matrix (relative to the object parent,
78    * be it an object, bone or vertex(-tices)). */
79   Matrix f_obmat;
80   BKE_object_matrix_local_get(ob, f_obmat);
81
82   if (export_settings.get_apply_global_orientation()) {
83     bc_apply_global_transform(f_obmat, export_settings.get_global_transform());
84   }
85   else {
86     bc_add_global_transform(f_obmat, export_settings.get_global_transform());
87   }
88
89   switch (transformation_type) {
90     case BC_TRANSFORMATION_TYPE_MATRIX: {
91       UnitConverter converter;
92       double d_obmat[4][4];
93       converter.mat4_to_dae_double(d_obmat, f_obmat);
94       if (limit_precision)
95         bc_sanitize_mat(d_obmat, LIMITTED_PRECISION);
96       node.addMatrix("transform", d_obmat);
97       break;
98     }
99     case BC_TRANSFORMATION_TYPE_TRANSROTLOC: {
100       float loc[3], rot[3], scale[3];
101       bc_decompose(f_obmat, loc, rot, NULL, scale);
102       if (limit_precision) {
103         bc_sanitize_v3(loc, LIMITTED_PRECISION);
104         bc_sanitize_v3(rot, LIMITTED_PRECISION);
105         bc_sanitize_v3(scale, LIMITTED_PRECISION);
106       }
107       add_transform(node, loc, rot, scale);
108       break;
109     }
110   }
111 }
112
113 void TransformWriter::add_node_transform_identity(COLLADASW::Node &node)
114 {
115   float loc[3] = {0.0f, 0.0f, 0.0f}, scale[3] = {1.0f, 1.0f, 1.0f}, rot[3] = {0.0f, 0.0f, 0.0f};
116   add_transform(node, loc, rot, scale);
117 }
118
119 void TransformWriter::add_transform(COLLADASW::Node &node,
120                                     float loc[3],
121                                     float rot[3],
122                                     float scale[3])
123 {
124 #if 0
125   node.addRotateZ("rotationZ", COLLADABU::Math::Utils::radToDegF(rot[2]));
126   node.addRotateY("rotationY", COLLADABU::Math::Utils::radToDegF(rot[1]));
127   node.addRotateX("rotationX", COLLADABU::Math::Utils::radToDegF(rot[0]));
128 #endif
129   node.addTranslate("location", loc[0], loc[1], loc[2]);
130   node.addRotateZ("rotationZ", RAD2DEGF(rot[2]));
131   node.addRotateY("rotationY", RAD2DEGF(rot[1]));
132   node.addRotateX("rotationX", RAD2DEGF(rot[0]));
133   node.addScale("scale", scale[0], scale[1], scale[2]);
134 }