- added support for adding/parenting bones to armatures
[blender.git] / source / blender / python / api2_2x / Armature.c
1 /* 
2  *
3  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * This is a new part of Blender.
26  *
27  * Contributor(s): Jordi Rovira i Bonet
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30  */
31
32 #include "Armature.h"
33 #include "Bone.h"
34
35 #include <stdio.h>
36
37 #include <BKE_main.h>
38 #include <BKE_global.h>
39 #include <BKE_object.h>
40 #include <BKE_armature.h>
41 #include <BKE_library.h>
42 #include <BLI_blenlib.h>
43 #include <BLI_arithb.h>
44
45 #include "constant.h"
46 #include "gen_utils.h"
47 #include "modules.h"
48 #include "Types.h"
49
50 /*****************************************************************************/
51 /* Python API function prototypes for the Armature module.                   */
52 /*****************************************************************************/
53 static PyObject *M_Armature_New (PyObject * self, PyObject * args,
54                                  PyObject * keywords);
55 static PyObject *M_Armature_Get (PyObject * self, PyObject * args);
56 PyObject *Armature_Init (void);
57
58 /*****************************************************************************/
59 /* The following string definitions are used for documentation strings.      */
60 /* In Python these will be written to the console when doing a               */
61 /* Blender.Armature.__doc__                                                  */
62 /*****************************************************************************/
63 char M_Armature_doc[] = "The Blender Armature module\n\n\
64 This module provides control over **Armature Data** objects in Blender.\n";
65
66 char M_Armature_New_doc[] = "(name) - return a new Armature datablock of \n\
67           optional name 'name'.";
68
69 char M_Armature_Get_doc[] =
70   "(name) - return the armature with the name 'name', \
71 returns None if not found.\n If 'name' is not specified, \
72 it returns a list of all armatures in the\ncurrent scene.";
73
74 char M_Armature_get_doc[] = "(name) - DEPRECATED. Use 'Get' instead. \
75 return the armature with the name 'name', \
76 returns None if not found.\n If 'name' is not specified, \
77 it returns a list of all armatures in the\ncurrent scene.";
78
79 /*****************************************************************************/
80 /* Python method structure definition for Blender.Armature module:           */
81 /*****************************************************************************/
82 struct PyMethodDef M_Armature_methods[] = {
83   {"New", (PyCFunction) M_Armature_New, METH_VARARGS | METH_KEYWORDS,
84    M_Armature_New_doc},
85   {"Get", M_Armature_Get, METH_VARARGS, M_Armature_Get_doc},
86   {"get", M_Armature_Get, METH_VARARGS, M_Armature_get_doc},
87   {NULL, NULL, 0, NULL}
88 };
89
90 /*****************************************************************************/
91 /* Python BPy_Armature methods declarations:                                 */
92 /*****************************************************************************/
93 static PyObject *Armature_getName (BPy_Armature * self);
94 static PyObject *Armature_getBones (BPy_Armature * self);
95 static PyObject *Armature_addBone(BPy_Armature *self, PyObject *args);
96 static PyObject *Armature_setName (BPy_Armature * self, PyObject * args);
97 /* static PyObject *Armature_setBones(BPy_Armature *self, PyObject *args); */
98
99 /*****************************************************************************/
100 /* Python BPy_Armature methods table:                                        */
101 /*****************************************************************************/
102 static PyMethodDef BPy_Armature_methods[] = {
103   /* name, method, flags, doc */
104   {"getName", (PyCFunction) Armature_getName, METH_NOARGS,
105    "() - return Armature name"},
106   {"getBones", (PyCFunction) Armature_getBones, METH_NOARGS,
107    "() - return Armature root bones"},
108   {"setName", (PyCFunction) Armature_setName, METH_VARARGS,
109    "(str) - rename Armature"},
110   {"addBone", (PyCFunction)Armature_addBone, METH_VARARGS,
111         "(bone)-add bone"},
112   /*  {"setBones", (PyCFunction)Armature_setBones, METH_VARARGS,
113      "(list of bones) - replace the whole bone list of the armature"},
114    */
115   {NULL, NULL, 0, NULL}
116 };
117
118 /*****************************************************************************/
119 /* Python TypeArmature callback function prototypes:                         */
120 /*****************************************************************************/
121 static void Armature_dealloc (BPy_Armature * armature);
122 static PyObject *Armature_getAttr (BPy_Armature * armature, char *name);
123 static int Armature_setAttr (BPy_Armature * armature, char *name,
124                              PyObject * v);
125 static int Armature_compare (BPy_Armature * a1, BPy_Armature * a2);
126 static PyObject *Armature_repr (BPy_Armature * armature);
127
128 static int doesBoneName_exist(char *name, bArmature* arm);
129 /*****************************************************************************/
130 /* Python TypeArmature structure definition:                                 */
131 /*****************************************************************************/
132 PyTypeObject Armature_Type = {
133   PyObject_HEAD_INIT (NULL) 0,  /* ob_size */
134   "Blender Armature",           /* tp_name */
135   sizeof (BPy_Armature),        /* tp_basicsize */
136   0,                            /* tp_itemsize */
137   /* methods */
138   (destructor) Armature_dealloc,        /* tp_dealloc */
139   0,                            /* tp_print */
140   (getattrfunc) Armature_getAttr,       /* tp_getattr */
141   (setattrfunc) Armature_setAttr,       /* tp_setattr */
142   (cmpfunc) Armature_compare,   /* tp_compare */
143   (reprfunc) Armature_repr,     /* tp_repr */
144   0,                            /* tp_as_number */
145   0,                            /* tp_as_sequence */
146   0,                            /* tp_as_mapping */
147   0,                            /* tp_as_hash */
148   0, 0, 0, 0, 0, 0,
149   0,                            /* tp_doc */
150   0, 0, 0, 0, 0, 0,
151   BPy_Armature_methods,         /* tp_methods */
152   0,                            /* tp_members */
153 };
154
155
156 /*****************************************************************************/
157 /* Function:              M_Armature_New                                     */
158 /* Python equivalent:     Blender.Armature.New                               */
159 /*****************************************************************************/
160 static PyObject *
161 M_Armature_New (PyObject * self, PyObject * args, PyObject * keywords)
162 {
163   char        *name_str = "ArmatureData";
164   BPy_Armature  *py_armature; /* for Armature Data object wrapper in Python */
165   bArmature   *bl_armature; /* for actual Armature Data we create in Blender */
166   char        buf[21];
167
168   if (!PyArg_ParseTuple(args, "|s", &name_str))
169     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
170            "expected string or empty argument"));
171
172   bl_armature = add_armature(); /* first create in Blender */
173   
174   if (bl_armature){
175     /* return user count to zero because add_armature() inc'd it */
176     bl_armature->id.us = 0;
177     /* now create the wrapper obj in Python */
178     py_armature = (BPy_Armature *)PyObject_NEW(BPy_Armature, &Armature_Type);
179   }
180   else
181     return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
182            "couldn't create Armature Data in Blender"));
183
184   if (py_armature == NULL)
185     return (EXPP_ReturnPyObjError (PyExc_MemoryError,
186            "couldn't create ArmaturePyObject"));
187
188   /* link Python armature wrapper with Blender Armature: */
189   py_armature->armature = bl_armature;
190
191   if (strcmp(name_str, "ArmatureData") == 0)
192     return (PyObject *)py_armature;
193   else { /* user gave us a name for the armature, use it */
194     PyOS_snprintf(buf, sizeof(buf), "%s", name_str);
195     rename_id(&bl_armature->id, buf);
196   }
197
198   return (PyObject *)py_armature;
199 }
200
201 /*****************************************************************************/
202 /* Function:              M_Armature_Get                                     */
203 /* Python equivalent:     Blender.Armature.Get                               */
204 /*****************************************************************************/
205 static PyObject *
206 M_Armature_Get (PyObject * self, PyObject * args)
207 {
208   char *name = NULL;
209   bArmature *armature_iter;
210   BPy_Armature *wanted_armature;
211
212   if (!PyArg_ParseTuple (args, "|s", &name))
213     return (EXPP_ReturnPyObjError (PyExc_TypeError,
214                                    "expected string argument (or nothing)"));
215
216   armature_iter = G.main->armature.first;
217
218   /* Use the name to search for the armature requested. */
219
220   if (name)
221     {                           /* (name) - Search armature by name */
222       wanted_armature = NULL;
223
224       while ((armature_iter) && (wanted_armature == NULL))
225         {
226
227           if (strcmp (name, armature_iter->id.name + 2) == 0)
228             {
229               wanted_armature =
230                 (BPy_Armature *) PyObject_NEW (BPy_Armature, &Armature_Type);
231               if (wanted_armature)
232                 wanted_armature->armature = armature_iter;
233             }
234
235           armature_iter = armature_iter->id.next;
236         }
237
238       if (wanted_armature == NULL)
239         {                       /* Requested Armature doesn't exist */
240           char error_msg[64];
241           PyOS_snprintf (error_msg, sizeof (error_msg),
242                          "Armature \"%s\" not found", name);
243           return (EXPP_ReturnPyObjError (PyExc_NameError, error_msg));
244         }
245
246       return (PyObject *) wanted_armature;
247     }
248
249   else
250     {
251       /* Return a list of with armatures in the scene */
252       int index = 0;
253       PyObject *armlist, *pyobj;
254
255       armlist = PyList_New (BLI_countlist (&(G.main->armature)));
256
257       if (armlist == NULL)
258         return (PythonReturnErrorObject (PyExc_MemoryError,
259                                          "couldn't create PyList"));
260
261       while (armature_iter)
262         {
263           pyobj = Armature_CreatePyObject (armature_iter);
264
265           if (!pyobj)
266             return (PythonReturnErrorObject (PyExc_MemoryError,
267                                              "couldn't create PyString"));
268
269           PyList_SET_ITEM (armlist, index, pyobj);
270
271           armature_iter = armature_iter->id.next;
272           index++;
273         }
274
275       return (armlist);
276     }
277
278 }
279
280 /*****************************************************************************/
281 /* Function:              Armature_Init                                      */
282 /*****************************************************************************/
283 PyObject *
284 Armature_Init (void)
285 {
286   PyObject *submodule;
287   PyObject *dict;
288
289   Armature_Type.ob_type = &PyType_Type;
290
291   submodule = Py_InitModule3 ("Blender.Armature",
292                               M_Armature_methods, M_Armature_doc);
293
294   /* Add the Bone submodule to this module */
295   dict = PyModule_GetDict (submodule);
296   PyDict_SetItemString (dict, "Bone", Bone_Init ());
297
298   return (submodule);
299 }
300
301 /*****************************************************************************/
302 /* Python BPy_Armature methods:                                              */
303 /*****************************************************************************/
304 static PyObject *
305 Armature_getName (BPy_Armature * self)
306 {
307   PyObject *attr = PyString_FromString (self->armature->id.name + 2);
308
309   if (attr)
310     return attr;
311
312   return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
313                                  "couldn't get Armature.name attribute"));
314 }
315
316
317 /** Create and return a list of the root bones for this armature. */
318 static PyObject *
319 Armature_getBones (BPy_Armature * self)
320 {
321   int totbones = 0;
322   PyObject *listbones = NULL;
323   Bone *current = NULL;
324   int i;
325
326   /* Count the number of bones to create the list */
327   current = self->armature->bonebase.first;
328   for (; current; current = current->next)
329     totbones++;
330
331   /* Create a list with a bone wrapper for each bone */
332   current = self->armature->bonebase.first;
333   listbones = PyList_New (totbones);
334   for (i = 0; i < totbones; i++)
335     {
336       /* Wrap and set to corresponding element of the list. */
337       PyList_SetItem (listbones, i, Bone_CreatePyObject (current));
338       current = current->next;
339     }
340
341   return listbones;
342 }
343
344 static void
345 unique_BoneName(char *name, bArmature* arm)
346 {
347   char tempname[64];
348   int number;
349   char *dot;
350
351   if (doesBoneName_exist(name, arm)){
352         /*      Strip off the suffix */
353         dot=strchr(name, '.');
354         if (dot)
355                 *dot=0;
356         
357         for (number = 1; number <=999; number++){
358                 sprintf (tempname, "%s.%03d", name, number);
359                 if (!doesBoneName_exist(tempname, arm)){
360                         strcpy (name, tempname);
361                         return;
362                 }
363         }
364   }
365 }
366
367 static int 
368 doesBoneName_exist(char *name, bArmature* arm)
369 {
370   Bone *parent = NULL;
371   Bone *child = NULL;
372
373   for (parent = arm->bonebase.first; parent; parent = parent->next){
374     if (!strcmp (name, parent->name))
375                 return 1;
376         for (child = parent->childbase.first; child; child = child->next){
377                 if (!strcmp (name, child->name))
378                     return 1;
379         }
380   }
381   return 0;
382 }
383
384 static PyObject *Armature_addBone(BPy_Armature *self, PyObject *args)
385 {
386         BPy_Bone* py_bone = NULL;
387         float M_boneObjectspace[4][4];
388         float M_parentRest[4][4];
389         float iM_parentRest[4][4];
390         float delta[3];
391         float rootHead[3];
392         float rootTail[3];
393
394         
395         if (!PyArg_ParseTuple(args, "O!", &Bone_Type, &py_bone))
396                 return (EXPP_ReturnPyObjError (PyExc_TypeError, 
397                         "expected bone object argument (or nothing)"));
398
399         if(py_bone != NULL)
400                 if(!py_bone->bone)
401                         return (EXPP_ReturnPyObjError (PyExc_TypeError, "bone contains no data!"));
402
403         //make sure the name is unique for this armature
404         unique_BoneName(py_bone->bone->name, self->armature);
405
406         //if bone has a parent....      
407         if(py_bone->bone->parent){
408                 
409                 //add to parent's childbase
410                 BLI_addtail (&py_bone->bone->parent->childbase, py_bone->bone);
411                 
412                 //get the worldspace coords for the parent
413                 get_objectspace_bone_matrix(py_bone->bone->parent, M_boneObjectspace, 1,0);
414                 rootHead[0] = M_boneObjectspace[3][0];
415                 rootHead[1] = M_boneObjectspace[3][1];
416                 rootHead[2] = M_boneObjectspace[3][2];
417                 get_objectspace_bone_matrix(py_bone->bone->parent, M_boneObjectspace, 0,0);
418                 rootTail[0] = M_boneObjectspace[3][0];
419                 rootTail[1] = M_boneObjectspace[3][1];
420                 rootTail[2] = M_boneObjectspace[3][2];
421
422                 //rest matrix of parent
423                 VecSubf (delta, rootTail, rootHead);
424                 make_boneMatrixvr(M_parentRest, delta, py_bone->bone->parent->roll);
425
426                 // Invert the parent rest matrix
427                 Mat4Invert (iM_parentRest, M_parentRest);
428
429                 // Get the new head and tail 
430                 VecSubf (py_bone->bone->head, py_bone->bone->head, rootTail);
431                 VecSubf (py_bone->bone->tail, py_bone->bone->tail, rootTail);
432
433                 //transformation of local bone
434                 Mat4MulVecfl(iM_parentRest, py_bone->bone->head);
435                 Mat4MulVecfl(iM_parentRest, py_bone->bone->tail);
436
437         }else //no parent....
438                 BLI_addtail (&self->armature->bonebase,py_bone->bone);
439
440         precalc_bonelist_irestmats(&self->armature->bonebase);
441
442         Py_INCREF(Py_None);
443         return Py_None;
444 }
445
446 static PyObject *
447 Armature_setName (BPy_Armature * self, PyObject * args)
448 {
449   char *name;
450   char buf[21];
451
452   if (!PyArg_ParseTuple (args, "s", &name))
453     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
454                                    "expected string argument"));
455
456   PyOS_snprintf (buf, sizeof (buf), "%s", name);
457
458   rename_id (&self->armature->id, buf);
459
460   Py_INCREF (Py_None);
461   return Py_None;
462 }
463
464 /*****************************************************************************/
465 /* Function:    Armature_dealloc                                             */
466 /* Description: This is a callback function for the BPy_Armature type. It is */
467 /*              the destructor function.                                     */
468 /*****************************************************************************/
469 static void
470 Armature_dealloc (BPy_Armature * self)
471 {
472   PyObject_DEL (self);
473 }
474
475 /*****************************************************************************/
476 /* Function:    Armature_getAttr                                             */
477 /* Description: This is a callback function for the BPy_Armature type. It is */
478 /*              the function that accesses BPy_Armature member variables and */
479 /*              methods.                                                     */
480 /*****************************************************************************/
481 static PyObject *
482 Armature_getAttr (BPy_Armature * self, char *name)
483 {
484   PyObject *attr = Py_None;
485
486   if (strcmp (name, "name") == 0)
487     attr = Armature_getName (self);
488   if (strcmp (name, "bones") == 0)
489     attr = Armature_getBones (self);
490   else if (strcmp (name, "__members__") == 0)
491     {
492       /* 2 entries */
493       attr = Py_BuildValue ("[s,s]", "name", "bones");
494     }
495
496   if (!attr)
497     return (EXPP_ReturnPyObjError (PyExc_MemoryError,
498                                    "couldn't create PyObject"));
499
500   if (attr != Py_None)
501     return attr;                /* member attribute found, return it */
502
503   /* not an attribute, search the methods table */
504   return Py_FindMethod (BPy_Armature_methods, (PyObject *) self, name);
505 }
506
507 /*****************************************************************************/
508 /* Function:    Armature_setAttr                                             */
509 /* Description: This is a callback function for the BPy_Armature type. It is */
510 /*              the function that changes Armature Data members values. If   */
511 /*              this data is linked to a Blender Armature, it also gets      */
512 /*              updated.                                                     */
513 /*****************************************************************************/
514 static int
515 Armature_setAttr (BPy_Armature * self, char *name, PyObject * value)
516 {
517   PyObject *valtuple;
518   PyObject *error = NULL;
519
520   valtuple = Py_BuildValue ("(O)", value);      /*the set* functions expect a tuple */
521
522   if (!valtuple)
523     return EXPP_ReturnIntError (PyExc_MemoryError,
524                                 "ArmatureSetAttr: couldn't create tuple");
525
526   if (strcmp (name, "name") == 0)
527     error = Armature_setName (self, valtuple);
528   /*  if (strcmp (name, "bones") == 0)
529      error = Armature_setBones (self, valtuple); */
530   else
531     {                           /* Error */
532       Py_DECREF (valtuple);
533
534       /* ... member with the given name was found */
535       return (EXPP_ReturnIntError (PyExc_KeyError, "attribute not found"));
536     }
537
538   Py_DECREF (valtuple);
539
540   if (error != Py_None)
541     return -1;
542
543   Py_DECREF (Py_None);          /* was incref'ed by the called Armature_set* function */
544   return 0;                     /* normal exit */
545 }
546
547 /*****************************************************************************/
548 /* Function:    Armature_repr                                                */
549 /* Description: This is a callback function for the BPy_Armature type. It    */
550 /*              builds a meaninful string to represent armature objects.     */
551 /*****************************************************************************/
552 static PyObject *
553 Armature_repr (BPy_Armature * self)
554 {
555   return PyString_FromFormat ("[Armature \"%s\"]",
556                               self->armature->id.name + 2);
557 }
558
559 /*****************************************************************************/
560 /* Function:    Armature_compare                                             */
561 /* Description: This is a callback function for the BPy_Armature type. It    */
562 /*              compares the two armatures: translate comparison to the      */
563 /*              C pointers.                                                  */
564 /*****************************************************************************/
565 static int
566 Armature_compare (BPy_Armature * a, BPy_Armature * b)
567 {
568   bArmature *pa = a->armature, *pb = b->armature;
569   return (pa == pb) ? 0 : -1;
570 }
571
572 /*****************************************************************************/
573 /* Function:    Armature_CreatePyObject                                      */
574 /* Description: This function will create a new BlenArmature from an         */
575 /*              existing Armature structure.                                 */
576 /*****************************************************************************/
577 PyObject *
578 Armature_CreatePyObject (struct bArmature * obj)
579 {
580   BPy_Armature *blen_armature;
581
582   blen_armature =
583     (BPy_Armature *) PyObject_NEW (BPy_Armature, &Armature_Type);
584
585   if (blen_armature == NULL)
586     {
587       return (NULL);
588     }
589   blen_armature->armature = obj;
590
591   return ((PyObject *) blen_armature);
592 }
593
594 /*****************************************************************************/
595 /* Function:    Armature_CheckPyObject                                       */
596 /* Description: This function returns true when the given PyObject is of the */
597 /*              type Armature. Otherwise it will return false.               */
598 /*****************************************************************************/
599 int
600 Armature_CheckPyObject (PyObject * py_obj)
601 {
602   return (py_obj->ob_type == &Armature_Type);
603 }
604
605 /*****************************************************************************/
606 /* Function:    Armature_FromPyObject                                        */
607 /* Description: This function returns the Blender armature from the given    */
608 /*              PyObject.                                                    */
609 /*****************************************************************************/
610 struct bArmature *
611 Armature_FromPyObject (PyObject * py_obj)
612 {
613   BPy_Armature *blen_obj;
614
615   blen_obj = (BPy_Armature *) py_obj;
616   return (blen_obj->armature);
617 }