svn merge -r 21041:21301 https://svn.blender.org/svnroot/bf-blender/branches/blender2...
[blender.git] / source / gameengine / Ketsji / KX_PyMath.cpp
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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): none yet.
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  * Initialize Python thingies.
29  */
30
31 #ifdef HAVE_CONFIG_H
32 #include <config.h>
33 #endif
34
35 #ifdef WIN32
36 #pragma warning (disable : 4786)
37 #endif //WIN32
38
39 #include "MT_Vector3.h"
40 #include "MT_Vector4.h"
41 #include "MT_Matrix4x4.h"
42 #include "MT_Point2.h"
43
44 #include "ListValue.h"
45
46 #include "KX_Python.h"
47 #include "KX_PyMath.h"
48
49 bool PyOrientationTo(PyObject* pyval, MT_Matrix3x3 &rot, const char *error_prefix)
50 {
51         int size= PySequence_Size(pyval);
52         
53         if (size == 4)
54         {
55                 MT_Quaternion qrot;
56                 if (PyQuatTo(pyval, qrot))
57                 {
58                         rot.setRotation(qrot);
59                         return true;
60                 }
61         }
62         else if (size == 3) {
63                 /* 3x3 matrix or euler */
64                 MT_Vector3 erot;
65                 if (PyVecTo(pyval, erot))
66                 {
67                         rot.setEuler(erot);
68                         return true;
69                 }
70                 PyErr_Clear();
71                 
72                 if (PyMatTo(pyval, rot))
73                 {
74                         return true;
75                 }
76         }
77         
78         PyErr_Format(PyExc_TypeError, "%s, could not set the orientation from a 3x3 matrix, quaternion or euler sequence", error_prefix);
79         return false;
80 }
81
82 bool PyQuatTo(PyObject* pyval, MT_Quaternion &qrot)
83 {
84         if(!PyVecTo(pyval, qrot))
85                 return false;
86
87         /* annoying!, Blender/Mathutils have the W axis first! */
88         MT_Scalar w= qrot[0]; /* from python, this is actually the W */
89         qrot[0]= qrot[1];
90         qrot[1]= qrot[2];
91         qrot[2]= qrot[3];
92         qrot[3]= w;
93
94         return true;
95 }
96
97 PyObject* PyObjectFrom(const MT_Matrix4x4 &mat)
98 {
99 #ifdef USE_MATHUTILS
100         float fmat[16];
101         mat.getValue(fmat);
102         return newMatrixObject(fmat, 4, 4, Py_NEW, NULL);
103 #else
104         PyObject *list = PyList_New(4);
105         PyObject *sublist;
106         int i;
107         
108         for(i=0; i < 4; i++) {
109                 sublist = PyList_New(4);
110                 PyList_SET_ITEM(sublist, 0, PyFloat_FromDouble(mat[i][0]));
111                 PyList_SET_ITEM(sublist, 1, PyFloat_FromDouble(mat[i][1]));
112                 PyList_SET_ITEM(sublist, 2, PyFloat_FromDouble(mat[i][2]));
113                 PyList_SET_ITEM(sublist, 3, PyFloat_FromDouble(mat[i][3]));
114                 PyList_SET_ITEM(list, i, sublist);
115         }
116         
117         return list;
118 #endif
119 }
120
121 PyObject* PyObjectFrom(const MT_Matrix3x3 &mat)
122 {
123 #ifdef USE_MATHUTILS
124         float fmat[9];
125         mat.getValue3x3(fmat);
126         return newMatrixObject(fmat, 3, 3, Py_NEW, NULL);
127 #else
128         PyObject *list = PyList_New(3);
129         PyObject *sublist;
130         int i;
131         
132         for(i=0; i < 3; i++) {
133                 sublist = PyList_New(3);
134                 PyList_SET_ITEM(sublist, 0, PyFloat_FromDouble(mat[i][0]));
135                 PyList_SET_ITEM(sublist, 1, PyFloat_FromDouble(mat[i][1]));
136                 PyList_SET_ITEM(sublist, 2, PyFloat_FromDouble(mat[i][2]));
137                 PyList_SET_ITEM(list, i, sublist);
138         }
139         
140         return list;
141 #endif
142 }
143
144 #ifdef USE_MATHUTILS
145 PyObject* PyObjectFrom(const MT_Quaternion &qrot)
146 {
147         /* NOTE, were re-ordering here for Mathutils compat */
148         float fvec[4]= {qrot[3], qrot[0], qrot[1], qrot[2]};
149         return newQuaternionObject(fvec, Py_WRAP, NULL);
150 }
151 #endif
152
153 PyObject* PyObjectFrom(const MT_Tuple4 &vec)
154 {
155 #ifdef USE_MATHUTILS
156         float fvec[4]= {vec[0], vec[1], vec[2], vec[3]};
157         return newVectorObject(fvec, 4, Py_WRAP, NULL);
158 #else
159         PyObject *list = PyList_New(4);
160         PyList_SET_ITEM(list, 0, PyFloat_FromDouble(vec[0]));
161         PyList_SET_ITEM(list, 1, PyFloat_FromDouble(vec[1]));
162         PyList_SET_ITEM(list, 2, PyFloat_FromDouble(vec[2]));
163         PyList_SET_ITEM(list, 3, PyFloat_FromDouble(vec[3]));
164         return list;
165 #endif
166 }
167
168 PyObject* PyObjectFrom(const MT_Tuple3 &vec)
169 {
170 #ifdef USE_MATHUTILS
171         float fvec[3]= {vec[0], vec[1], vec[2]};
172         return newVectorObject(fvec, 3, Py_WRAP, NULL);
173 #else
174         PyObject *list = PyList_New(3);
175         PyList_SET_ITEM(list, 0, PyFloat_FromDouble(vec[0]));
176         PyList_SET_ITEM(list, 1, PyFloat_FromDouble(vec[1]));
177         PyList_SET_ITEM(list, 2, PyFloat_FromDouble(vec[2]));
178         return list;
179 #endif  
180 }
181
182 PyObject* PyObjectFrom(const MT_Tuple2 &vec)
183 {
184 #ifdef USE_MATHUTILS
185         float fvec[2]= {vec[0], vec[1]};
186         return newVectorObject(fvec, 2, Py_WRAP, NULL);
187 #else
188         PyObject *list = PyList_New(2);
189         PyList_SET_ITEM(list, 0, PyFloat_FromDouble(vec[0]));
190         PyList_SET_ITEM(list, 1, PyFloat_FromDouble(vec[1]));
191         return list;
192 #endif
193 }