997d4e364002748836d0a280c6c5160c34a22a01
[blender-staging.git] / source / blender / python / api2_2x / Key.c
1 /* 
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL 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. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA        02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * This is a new part of Blender.
27  *
28  * Contributor(s): Pontus Lidman
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  */
32
33 #include <BLI_blenlib.h>
34 #include <BKE_global.h>
35 #include <BKE_main.h>
36
37 #include "Key.h"
38 #include "NMesh.h" /* we create NMesh.NMVert objects */
39 #include "Ipo.h"
40 #include "BezTriple.h"
41
42 #include "constant.h"
43 #include "gen_utils.h"
44
45 #define KEY_TYPE_MESH    0
46 #define KEY_TYPE_CURVE   1
47 #define KEY_TYPE_LATTICE 2
48
49 /* macro from blenkernel/intern/key.c:98 */
50 #define GS(a)   (*((short *)(a)))
51
52 static void Key_dealloc( PyObject * self );
53 static PyObject *Key_getattr( PyObject * self, char *name );
54 static void KeyBlock_dealloc( PyObject * self );
55 static PyObject *KeyBlock_getattr( PyObject * self, char *name );
56 static PyObject *Key_repr( BPy_Key * self );
57
58 PyTypeObject Key_Type = {
59         PyObject_HEAD_INIT( NULL ) 0,   /*ob_size */
60         "Blender Key",  /*tp_name */
61         sizeof( BPy_Key ),      /*tp_basicsize */
62         0,                      /*tp_itemsize */
63         /* methods */
64         ( destructor ) Key_dealloc,     /*tp_dealloc */
65         ( printfunc ) 0,        /*tp_print */
66         ( getattrfunc ) Key_getattr,    /*tp_getattr */
67         ( setattrfunc ) 0,      /*tp_setattr */
68         0, /*tp_compare*/
69         ( reprfunc ) Key_repr, /* tp_repr */
70         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
71         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
72 };
73
74 PyTypeObject KeyBlock_Type = {
75         PyObject_HEAD_INIT( NULL ) 0,   /*ob_size */
76         "Blender KeyBlock",     /*tp_name */
77         sizeof( BPy_KeyBlock ), /*tp_basicsize */
78         0,                      /*tp_itemsize */
79         /* methods */
80         ( destructor ) KeyBlock_dealloc,        /*tp_dealloc */
81         ( printfunc ) 0,        /*tp_print */
82         ( getattrfunc ) KeyBlock_getattr,       /*tp_getattr */
83         ( setattrfunc ) 0,      /*tp_setattr */
84         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
85         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
86 };
87
88 static PyObject *Key_getBlocks( PyObject * self );
89 static PyObject *Key_getType( PyObject * self );
90 static PyObject *Key_getIpo( PyObject * self );
91 static PyObject *Key_getValue( PyObject * self );
92
93 static struct PyMethodDef Key_methods[] = {
94         { "getType", (PyCFunction) Key_getType, METH_NOARGS, "Get key type" },
95         { "getValue", (PyCFunction) Key_getValue, METH_NOARGS, "Get key value" },
96         { "getBlocks", (PyCFunction) Key_getBlocks, METH_NOARGS, "Get key blocks" },
97         { "getIpo", (PyCFunction) Key_getIpo, METH_NOARGS, "Get key Ipo" },
98         { 0, 0, 0, 0 }
99 };
100
101 static PyObject *KeyBlock_getData( PyObject * self );
102 static PyObject *KeyBlock_getPos( PyObject * self );
103
104 static struct PyMethodDef KeyBlock_methods[] = {
105         { "getPos", (PyCFunction) KeyBlock_getPos, METH_NOARGS,
106                 "Get keyblock position"},
107         { "getData", (PyCFunction) KeyBlock_getData, METH_NOARGS,
108                 "Get keyblock data" },
109         { 0, 0, 0, 0 }
110 };
111
112 static void Key_dealloc( PyObject * self )
113 {
114         PyObject_DEL( self );
115 }
116
117 static PyObject *new_Key(Key * oldkey)
118 {
119         BPy_Key *k = PyObject_NEW( BPy_Key, &Key_Type );
120
121         if( !oldkey ) {
122                 k->key = 0;
123         } else {
124                 k->key = oldkey;
125         }
126         return ( PyObject * ) k;
127 }
128
129 PyObject *Key_CreatePyObject( Key * k )
130 {
131         BPy_Key *key = ( BPy_Key * ) new_Key( k );
132
133         return ( PyObject * ) key;
134 }
135
136 static PyObject *Key_getattr( PyObject * self, char *name )
137 {
138         BPy_Key *k = ( BPy_Key * ) self;
139         if ( strcmp( name, "id" ) == 0 ) {
140                 return PyString_FromString( k->key->id.name );
141         } else if ( strcmp( name, "type" ) == 0 ) {
142                 return Key_getType(self);
143         } else if ( strcmp( name, "value" ) == 0 ) {
144                 return Key_getValue(self);
145         } else if ( strcmp( name, "blocks" ) == 0 ) {
146                 return Key_getBlocks(self);
147         } else if ( strcmp( name, "ipo" ) == 0 ) {
148                 return Key_getIpo(self);
149         }
150         return Py_FindMethod( Key_methods, ( PyObject * ) self, name );
151
152 }
153
154 static PyObject *Key_repr( BPy_Key * self )
155 {
156         return PyString_FromFormat( "[Key \"%s\"]", self->key->id.name + 2 );
157 }
158
159 static PyObject *Key_getValue( PyObject * self )
160 {
161         BPy_Key *k = ( BPy_Key * ) self;
162
163         return PyFloat_FromDouble( k->key->curval );
164 }
165
166 static PyObject *Key_getIpo( PyObject * self )
167 {
168         BPy_Key *k = ( BPy_Key * ) self;
169         BPy_Ipo *new_ipo;
170
171         if (k->key->ipo) {
172                 new_ipo = ( BPy_Ipo * ) PyObject_NEW( BPy_Ipo, &Ipo_Type );
173                 new_ipo->ipo = k->key->ipo;
174                 return (PyObject *) new_ipo;
175         } else {
176                 return EXPP_incr_ret( Py_None );
177         }
178 }
179
180 static PyObject *Key_getType( PyObject * self )
181 {
182         BPy_Key *k = ( BPy_Key * ) self;
183         int idcode;
184         int type = -1;
185
186         idcode = GS( k->key->from->name );
187
188         switch( idcode ) {
189         case ID_ME:
190                 type = KEY_TYPE_MESH;
191                 break;
192         case ID_CU:
193                 type = KEY_TYPE_CURVE;
194                 break;
195         case ID_LT:
196                 type = KEY_TYPE_LATTICE;
197                 break;
198         }
199
200         return PyInt_FromLong( type );
201 }
202
203 static PyObject *Key_getBlocks( PyObject * self )
204 {
205         BPy_Key *k = ( BPy_Key * ) self;
206         Key *key = k->key;
207         KeyBlock *kb;
208         PyObject *keyblock_object;
209         PyObject *l = PyList_New( 0 );
210
211         for (kb = key->block.first; kb; kb = kb->next) {
212                 
213                 keyblock_object =  KeyBlock_CreatePyObject( kb, key );
214                 PyList_Append( l, keyblock_object );
215         }
216
217         return l;
218 }
219
220 static void KeyBlock_dealloc( PyObject * self )
221 {
222         PyObject_DEL( self );
223 }
224
225 static PyObject *new_KeyBlock( KeyBlock * oldkeyBlock, Key *parentKey)
226 {
227         BPy_KeyBlock *kb = PyObject_NEW( BPy_KeyBlock, &KeyBlock_Type );
228
229         kb->key = parentKey;
230
231         if( !oldkeyBlock ) {
232                 kb->keyblock = 0;
233         } else {
234                 kb->keyblock = oldkeyBlock;
235         }
236         return ( PyObject * ) kb;
237 }
238
239 PyObject *KeyBlock_CreatePyObject( KeyBlock * kb, Key *parentKey )
240 {
241         BPy_KeyBlock *keyBlock = ( BPy_KeyBlock * ) new_KeyBlock( kb, parentKey );
242
243         return ( PyObject * ) keyBlock;
244 }
245
246 static PyObject *KeyBlock_getattr( PyObject * self, char *name )
247 {
248         if ( strcmp( name, "pos" ) == 0 ) {
249                 return KeyBlock_getPos(self);
250         } else if ( strcmp( name, "data" ) == 0 ) {
251                 return KeyBlock_getData(self);
252         } else if ( strcmp( name, "pos" ) == 0 ) {
253                 return KeyBlock_getPos(self);
254         }
255         return Py_FindMethod( KeyBlock_methods, ( PyObject * ) self, name );
256 }
257
258 static PyObject *KeyBlock_getPos( PyObject * self )
259 {
260         BPy_KeyBlock *kb = ( BPy_KeyBlock * ) self;
261         return PyFloat_FromDouble( kb->keyblock->pos );
262 }
263
264 static PyObject *KeyBlock_getData( PyObject * self )
265 {
266         /* If this is a mesh key, data is an array of MVert.
267            If lattice, data is an array of BPoint
268            If curve, data is an array of BezTriple */
269
270         BPy_KeyBlock *kb = ( BPy_KeyBlock * ) self;
271         Key *key = kb->key;
272         char *datap;
273         int datasize;
274         int idcode;
275         int i;
276
277         PyObject *l = PyList_New( kb->keyblock->totelem );
278
279         idcode = GS( key->from->name );
280
281         if (!kb->keyblock->data) {
282                 return EXPP_incr_ret( Py_None );
283         }
284
285         switch(idcode) {
286         case ID_ME:
287
288                 datasize = sizeof(MVert);
289
290                 for (i=0, datap = kb->keyblock->data; i<kb->keyblock->totelem; i++) {
291
292                         BPy_NMVert *mv = PyObject_NEW( BPy_NMVert, &NMVert_Type );
293                         MVert *vert = (MVert *) datap;
294
295                         mv->co[0]=vert->co[0];
296                         mv->co[1]=vert->co[1];
297                         mv->co[2]=vert->co[2];
298                         mv->no[0] = vert->no[0] / 32767.0;
299                         mv->no[1] = vert->no[1] / 32767.0;
300                         mv->no[2] = vert->no[2] / 32767.0;
301
302                         mv->uvco[0] = mv->uvco[1] = mv->uvco[2] = 0.0;
303                         mv->index = i;
304                         mv->flag = 0;
305
306                         PyList_SetItem(l, i, ( PyObject * ) mv);
307
308                         datap += datasize;
309                 }
310                 break;
311
312         case ID_CU:
313
314                 datasize = sizeof(BezTriple);
315
316                 for (i=0, datap = kb->keyblock->data; i<kb->keyblock->totelem; i++) {
317
318                         BezTriple *bt = (BezTriple *) datap;
319                         PyObject *pybt = BezTriple_CreatePyObject( bt );
320
321                         PyList_SetItem( l, i, pybt );
322
323                         datap += datasize;
324                 }
325                 break;
326
327         case ID_LT:
328
329                 datasize = sizeof(BPoint);
330
331                 for (i=0, datap = kb->keyblock->data; i<kb->keyblock->totelem; i++) {
332                         /* Lacking a python class for BPoint, use a list of four floats */
333                         BPoint *bp = (BPoint *) datap;
334                         PyObject *bpoint = PyList_New( 4 );
335
336                         PyList_SetItem( bpoint, 0, PyFloat_FromDouble( bp->vec[0] ) );
337                         PyList_SetItem( bpoint, 1, PyFloat_FromDouble( bp->vec[1] ) );
338                         PyList_SetItem( bpoint, 2, PyFloat_FromDouble( bp->vec[2] ) );
339                         PyList_SetItem( bpoint, 3, PyFloat_FromDouble( bp->vec[3] ) );
340
341                         PyList_SetItem( l, i, bpoint );
342
343                         datap += datasize;
344                 }
345                 break;
346         }
347         
348         return l;
349 }
350
351 static PyObject *M_Key_Get( PyObject * self, PyObject * args )
352 {
353         char *name = NULL;
354         Key *key_iter;
355         char error_msg[64];
356         int i;
357
358         if( !PyArg_ParseTuple( args, "|s", &name ) )
359                 return ( EXPP_ReturnPyObjError( PyExc_TypeError,
360                         "expected string argument (or nothing)" ) );
361
362         if ( name ) {
363                 for (key_iter = G.main->key.first; key_iter; key_iter=key_iter->id.next) {
364                         if  (strcmp ( key_iter->id.name + 2, name ) == 0 ) {
365                                 return Key_CreatePyObject( key_iter );
366                         }
367                 }
368
369                 PyOS_snprintf( error_msg, sizeof( error_msg ),
370                         "Key \"%s\" not found", name );
371                 return ( EXPP_ReturnPyObjError ( PyExc_NameError, error_msg ) );
372                 
373         }
374
375         else {
376
377                 PyObject *keylist;
378
379                 keylist = PyList_New( BLI_countlist( &( G.main->key ) ) );
380
381                 for ( i=0, key_iter = G.main->key.first; key_iter; key_iter=key_iter->id.next, i++ ) {
382                         PyList_SetItem(keylist, i, Key_CreatePyObject(key_iter));
383                 }
384                 return keylist;
385         }
386 }
387
388
389 struct PyMethodDef M_Key_methods[] = {
390         {"Get", M_Key_Get, METH_VARARGS, "Get a key or all key names"},
391         {NULL, NULL, 0, NULL}
392 };
393
394 PyObject *Key_Init( void )
395 {
396         PyObject *submodule, *KeyTypes;
397
398         Key_Type.ob_type = &PyType_Type;
399         KeyBlock_Type.ob_type = &PyType_Type;
400         
401         submodule =
402                 Py_InitModule3( "Blender.Key", M_Key_methods, "Key module" );
403
404         KeyTypes = PyConstant_New( );
405
406         PyConstant_Insert(( BPy_constant * ) KeyTypes, "MESH", PyInt_FromLong(KEY_TYPE_MESH));
407         PyConstant_Insert(( BPy_constant * ) KeyTypes, "CURVE", PyInt_FromLong(KEY_TYPE_CURVE));
408         PyConstant_Insert(( BPy_constant * ) KeyTypes, "LATTICE", PyInt_FromLong(KEY_TYPE_LATTICE));
409
410         PyModule_AddObject( submodule, "Types", KeyTypes);
411
412         /*
413         PyModule_AddIntConstant( submodule, "TYPE_MESH",    KEY_TYPE_MESH );
414         PyModule_AddIntConstant( submodule, "TYPE_CURVE",   KEY_TYPE_CURVE );
415         PyModule_AddIntConstant( submodule, "TYPE_LATTICE", KEY_TYPE_LATTICE );
416         */
417         return submodule;
418 }