263dabdc5582d666688b43810570ffce8068e843
[blender.git] / source / blender / python / api2_2x / Object.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): Michel Selten
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30 */
31
32 #include <Python.h>
33 #include <stdio.h>
34
35 #include <BKE_global.h>
36 #include <BKE_main.h>
37 #include <DNA_ika_types.h>
38 #include <DNA_object_types.h>
39
40 #include "gen_utils.h"
41
42 /*****************************************************************************/
43 /* Python API function prototypes for the Blender module.                    */
44 /*****************************************************************************/
45 PyObject *Object_New(PyObject *self, PyObject *args);
46 PyObject *Object_Get(PyObject *self, PyObject *args);
47 PyObject *Object_GetSelected (PyObject *self, PyObject *args);
48
49 /*****************************************************************************/
50 /* The following string definitions are used for documentation strings.      */
51 /* In Python these will be written to the console when doing a               */
52 /* Blender.__doc__                                                           */
53 /*****************************************************************************/
54 char Object_New_doc[] =
55 "(type) - Add a new object of type 'type' in the current scene";
56
57 char Object_Get_doc[] =
58 "(name) - return the object with the name 'name', returns None if not\
59         found.\n\
60         If 'name' is not specified, it returns a list of all objects in the\n\
61         current scene.";
62
63 char Object_GetSelected_doc[] =
64 "() - Returns a list of selected Objects in the active layer(s)\n\
65 The active object is the first in the list, if visible";
66
67 /*****************************************************************************/
68 /* Python BlenderObject structure definition.                                */
69 /*****************************************************************************/
70 typedef struct {
71         PyObject_HEAD
72         struct Object    *object;
73 } BlenObject;
74
75 /*****************************************************************************/
76 /* PythonTypeObject callback function prototypes                             */
77 /*****************************************************************************/
78 void ObjectDeAlloc (BlenObject *obj);
79 PyObject* ObjectGetAttr (BlenObject *obj, char *name);
80 int ObjectSetAttr (BlenObject *obj, char *name, PyObject *v);
81
82 /*****************************************************************************/
83 /* Python TypeObject structure definition.                                   */
84 /*****************************************************************************/
85 static PyTypeObject object_type =
86 {
87         PyObject_HEAD_INIT(&PyType_Type)
88         0,                                                              /* ob_size */
89         "Object",                                               /* tp_name */
90         sizeof (BlenObject),                    /* tp_basicsize */
91         0,                                                              /* tp_itemsize */
92         /* methods */
93         (destructor)ObjectDeAlloc,              /* tp_dealloc */
94         0,                                                              /* tp_print */
95         (getattrfunc)ObjectGetAttr,             /* tp_getattr */
96         (setattrfunc)ObjectSetAttr,             /* tp_setattr */
97         0,                                                              /* tp_compare */
98         0,                                                              /* tp_repr */
99         0,                                                              /* tp_as_number */
100         0,                                                              /* tp_as_sequence */
101         0,                                                              /* tp_as_mapping */
102         0,                                                              /* tp_as_hash */
103 };
104
105 /*****************************************************************************/
106 /* Python method structure definition.                                       */
107 /*****************************************************************************/
108 struct PyMethodDef Object_methods[] = {
109         {"New",         Object_New,         METH_VARARGS, Object_New_doc},
110         {"Get",         Object_Get,         METH_VARARGS, Object_Get_doc},
111         {"get",         Object_Get,         METH_VARARGS, Object_Get_doc},
112         {"getSelected", Object_GetSelected, METH_VARARGS, Object_GetSelected_doc},
113         {NULL, NULL}
114 };
115
116 /*****************************************************************************/
117 /* Function:              Object_New                                         */
118 /* Python equivalent:     Blender.Object.New                                 */
119 /*****************************************************************************/
120 PyObject *Object_New(PyObject *self, PyObject *args)
121 {
122         printf ("In Object_New()\n");
123         return (Py_None);
124 }
125
126 /*****************************************************************************/
127 /* Function:              Object_Get                                         */
128 /* Python equivalent:     Blender.Object.Get                                 */
129 /*****************************************************************************/
130 PyObject *Object_Get(PyObject *self, PyObject *args)
131 {
132         char            * name;
133         PyObject        * arg;
134         struct Object   * obj_iter;
135         BlenObject      * blen_object;
136
137         printf ("In Object_Get()\n");
138
139         if (!PyArg_ParseTuple(args, "O", &arg))
140         {
141                 /* We expected a string as an argument, but we didn't get one. */
142                 return (PythonReturnErrorObject (PyExc_AttributeError,
143                                         "expected string argument"));
144         }
145
146         if (!PyString_Check (arg))
147         {
148                 return (PythonReturnErrorObject (PyExc_AttributeError,
149                                         "expected string argument"));
150         }
151         name = PyString_AsString (arg);
152
153         /* Use the name to search for the object requested. */
154         /* Should this lookup be a new function in blenkernel/intern/object.c? */
155         blen_object = NULL;
156         obj_iter = G.main->object.first;
157         while ((obj_iter) && (blen_object == NULL))
158         {
159                 if (StringEqual (name, GetIdName (&(obj_iter->id))))
160                 {
161                         blen_object = (BlenObject*)PyObject_NEW
162                                 (BlenObject,
163                                  &object_type);
164
165                         blen_object->object = obj_iter;
166                 }
167                 obj_iter = obj_iter->id.next;
168         }
169
170         if (blen_object == NULL)
171         {
172                 /* No object exists with the name specified in the argument name. */
173                 return (PythonReturnErrorObject (PyExc_AttributeError,
174                                         "expected string argument"));
175         }
176
177         return ((PyObject*)blen_object);
178 }
179
180 /*****************************************************************************/
181 /* Function:              Object_GetSelected                                 */
182 /* Python equivalent:     Blender.Object.getSelected                         */
183 /*****************************************************************************/
184 PyObject *Object_GetSelected (PyObject *self, PyObject *args)
185 {
186         printf ("In Object_GetSelected()\n");
187
188         return (Py_None);
189 }
190
191 /*****************************************************************************/
192 /* Function:              initObject                                         */
193 /*****************************************************************************/
194 PyObject *initObject (void)
195 {
196         PyObject        * module;
197
198         printf ("In initObject()\n");
199
200         module = Py_InitModule("Object", Object_methods);
201
202         return (module);
203 }
204
205 /*****************************************************************************/
206 /* Function:    ObjectCreatePyObject                                         */
207 /* Description: This function will create a new BlenObject from an existing  */
208 /*              Object structure.                                            */
209 /*****************************************************************************/
210 PyObject* ObjectCreatePyObject (struct Object *obj)
211 {
212         BlenObject      * blen_object;
213
214         printf ("In ObjectCreatePyObject\n");
215
216         blen_object = (BlenObject*)PyObject_NEW
217                 (BlenObject,
218                  &object_type);
219
220         blen_object->object = obj;
221         return ((PyObject*)blen_object);
222 }
223
224 /*****************************************************************************/
225 /* Function:    ObjectDeAlloc                                                */
226 /* Description: This is a callback function for the BlenObject type. It is   */
227 /*              the destructor function.                                     */
228 /*****************************************************************************/
229 void ObjectDeAlloc (BlenObject *obj)
230 {
231         PyObject_DEL (obj);
232 }
233
234 /*****************************************************************************/
235 /* Function:    ObjectGetAttr                                                */
236 /* Description: This is a callback function for the BlenObject type. It is   */
237 /*              the function that retrieves any value from Blender and       */
238 /*              passes it to Python.                                         */
239 /*****************************************************************************/
240 PyObject* ObjectGetAttr (BlenObject *obj, char *name)
241 {
242         struct Object   * object;
243         struct Ika      * ika;
244
245         object = obj->object;
246         if (StringEqual (name, "LocX"))
247                 return (PyFloat_FromDouble(object->loc[0]));
248         if (StringEqual (name, "LocY"))
249                 return (PyFloat_FromDouble(object->loc[1]));
250         if (StringEqual (name, "LocZ"))
251                 return (PyFloat_FromDouble(object->loc[2]));
252         if (StringEqual (name, "loc"))
253         {
254                 printf ("This is not implemented yet. (vector)\n");
255                 return (Py_None);
256         }
257         if (StringEqual (name, "dLocX"))
258                 return (PyFloat_FromDouble(object->dloc[0]));
259         if (StringEqual (name, "dLocY"))
260                 return (PyFloat_FromDouble(object->dloc[1]));
261         if (StringEqual (name, "dLocZ"))
262                 return (PyFloat_FromDouble(object->dloc[2]));
263         if (StringEqual (name, "dloc"))
264         {
265                 printf ("This is not implemented yet. (vector)\n");
266                 return (Py_None);
267         }
268         if (StringEqual (name, "RotX"))
269                 return (PyFloat_FromDouble(object->rot[0]));
270         if (StringEqual (name, "RotY"))
271                 return (PyFloat_FromDouble(object->rot[1]));
272         if (StringEqual (name, "RotZ"))
273                 return (PyFloat_FromDouble(object->rot[2]));
274         if (StringEqual (name, "rot"))
275         {
276                 printf ("This is not implemented yet. (vector)\n");
277                 return (Py_None);
278         }
279         if (StringEqual (name, "dRotX"))
280                 return (PyFloat_FromDouble(object->drot[0]));
281         if (StringEqual (name, "dRotY"))
282                 return (PyFloat_FromDouble(object->drot[1]));
283         if (StringEqual (name, "dRotZ"))
284                 return (PyFloat_FromDouble(object->drot[2]));
285         if (StringEqual (name, "drot"))
286         {
287                 printf ("This is not implemented yet. (vector)\n");
288                 return (Py_None);
289         }
290         if (StringEqual (name, "SizeX"))
291                 return (PyFloat_FromDouble(object->size[0]));
292         if (StringEqual (name, "SizeY"))
293                 return (PyFloat_FromDouble(object->size[1]));
294         if (StringEqual (name, "SizeZ"))
295                 return (PyFloat_FromDouble(object->size[2]));
296         if (StringEqual (name, "size"))
297         {
298                 printf ("This is not implemented yet. (vector)\n");
299                 return (Py_None);
300         }
301         if (StringEqual (name, "dSizeX"))
302                 return (PyFloat_FromDouble(object->dsize[0]));
303         if (StringEqual (name, "dSizeY"))
304                 return (PyFloat_FromDouble(object->dsize[1]));
305         if (StringEqual (name, "dSizeZ"))
306                 return (PyFloat_FromDouble(object->dsize[2]));
307         if (StringEqual (name, "dsize"))
308         {
309                 printf ("This is not implemented yet. (vector)\n");
310                 return (Py_None);
311         }
312         if (strncmp (name,"Eff", 3) == 0)
313         {
314                 if ( (object->type == OB_IKA) && (object->data != NULL) )
315                 {
316                         ika = object->data;
317                         switch (name[3])
318                         {
319                                 case 'X':
320                                         return (PyFloat_FromDouble (ika->effg[0]));
321                                 case 'Y':
322                                         return (PyFloat_FromDouble (ika->effg[1]));
323                                 case 'Z':
324                                         return (PyFloat_FromDouble (ika->effg[2]));
325                                 default:
326                                         /* Do we need to display a sensible error message here? */
327                                         return (NULL);
328                         }
329                 }
330                 return (NULL);
331         }
332         if (StringEqual (name, "Layer"))
333                 return (PyInt_FromLong(object->lay));
334         if (StringEqual (name, "parent"))
335         {
336                 printf ("This is not implemented yet.\n");
337                 return (Py_None);
338         }
339         if (StringEqual (name, "track"))
340         {
341                 printf ("This is not implemented yet.\n");
342                 return (Py_None);
343         }
344         if (StringEqual (name, "data"))
345         {
346                 printf ("This is not implemented yet.\n");
347                 return (Py_None);
348         }
349         if (StringEqual (name, "ipo"))
350         {
351                 printf ("This is not implemented yet.\n");
352                 return (Py_None);
353         }
354         if (StringEqual (name, "mat"))
355         {
356                 printf ("This is not implemented yet. (matrix)\n");
357                 return (Py_None);
358         }
359         if (StringEqual (name, "matrix"))
360         {
361                 printf ("This is not implemented yet. (matrix)\n");
362                 return (Py_None);
363         }
364         if (StringEqual (name, "colbits"))
365         {
366                 printf ("This is not implemented yet.\n");
367                 return (Py_None);
368         }
369         if (StringEqual (name, "drawType"))
370         {
371                 printf ("This is not implemented yet.\n");
372                 return (Py_None);
373         }
374         if (StringEqual (name, "drawMode"))
375         {
376                 printf ("This is not implemented yet.\n");
377                 return (Py_None);
378         }
379         printf ("Unknown variable.\n");
380         return (Py_None);
381 }
382
383 /*****************************************************************************/
384 /* Function:    ObjectSetAttr                                                */
385 /* Description: This is a callback function for the BlenObject type. It is   */
386 /*              the function that retrieves any value from Python and sets   */
387 /*              it accordingly in Blender.                                   */
388 /*****************************************************************************/
389 int ObjectSetAttr (BlenObject *obj, char *name, PyObject *value)
390 {
391         struct Object   * object;
392         struct Ika      * ika;
393
394         object = obj->object;
395         if (StringEqual (name, "LocX"))
396                 return (!PyArg_Parse (value, "f", &(object->loc[0])));
397         if (StringEqual (name, "LocY"))
398                 return (!PyArg_Parse (value, "f", &(object->loc[1])));
399         if (StringEqual (name, "LocZ"))
400                 return (!PyArg_Parse (value, "f", &(object->loc[2])));
401         if (StringEqual (name, "loc"))
402         {
403                 printf ("This is not implemented yet. (vector)\n");
404                 return (0);
405         }
406         if (StringEqual (name, "dLocX"))
407                 return (!PyArg_Parse (value, "f", &(object->dloc[0])));
408         if (StringEqual (name, "dLocY"))
409                 return (!PyArg_Parse (value, "f", &(object->dloc[1])));
410         if (StringEqual (name, "dLocZ"))
411                 return (!PyArg_Parse (value, "f", &(object->dloc[2])));
412         if (StringEqual (name, "dloc"))
413         {
414                 printf ("This is not implemented yet. (vector)\n");
415                 return (0);
416         }
417         if (StringEqual (name, "RotX"))
418                 return (!PyArg_Parse (value, "f", &(object->rot[0])));
419         if (StringEqual (name, "RotY"))
420                 return (!PyArg_Parse (value, "f", &(object->rot[1])));
421         if (StringEqual (name, "RotZ"))
422                 return (!PyArg_Parse (value, "f", &(object->rot[2])));
423         if (StringEqual (name, "rot"))
424         {
425                 printf ("This is not implemented yet. (vector)\n");
426                 return (0);
427         }
428         if (StringEqual (name, "dRotX"))
429                 return (!PyArg_Parse (value, "f", &(object->drot[0])));
430         if (StringEqual (name, "dRotY"))
431                 return (!PyArg_Parse (value, "f", &(object->drot[1])));
432         if (StringEqual (name, "dRotZ"))
433                 return (!PyArg_Parse (value, "f", &(object->drot[2])));
434         if (StringEqual (name, "drot"))
435         {
436                 printf ("This is not implemented yet. (vector)\n");
437                 return (0);
438         }
439         if (StringEqual (name, "SizeX"))
440                 return (!PyArg_Parse (value, "f", &(object->size[0])));
441         if (StringEqual (name, "SizeY"))
442                 return (!PyArg_Parse (value, "f", &(object->size[1])));
443         if (StringEqual (name, "SizeZ"))
444                 return (!PyArg_Parse (value, "f", &(object->size[2])));
445         if (StringEqual (name, "size"))
446         {
447                 printf ("This is not implemented yet. (vector)\n");
448                 return (0);
449         }
450         if (StringEqual (name, "dSizeX"))
451                 return (!PyArg_Parse (value, "f", &(object->dsize[0])));
452         if (StringEqual (name, "dSizeY"))
453                 return (!PyArg_Parse (value, "f", &(object->dsize[1])));
454         if (StringEqual (name, "dSizeZ"))
455                 return (!PyArg_Parse (value, "f", &(object->dsize[2])));
456         if (StringEqual (name, "dsize"))
457         {
458                 printf ("This is not implemented yet. (vector)\n");
459                 return (0);
460         }
461         if (strncmp (name,"Eff", 3) == 0)
462         {
463                 if ( (object->type == OB_IKA) && (object->data != NULL) )
464                 {
465                         ika = object->data;
466                         switch (name[3])
467                         {
468                                 case 'X':
469                                         return (!PyArg_Parse (value, "f", &(ika->effg[0])));
470                                 case 'Y':
471                                         return (!PyArg_Parse (value, "f", &(ika->effg[1])));
472                                 case 'Z':
473                                         return (!PyArg_Parse (value, "f", &(ika->effg[2])));
474                                 default:
475                                         /* Do we need to display a sensible error message here? */
476                                         return (0);
477                         }
478                 }
479                 return (0);
480         }
481         if (StringEqual (name, "Layer"))
482                 return (!PyArg_Parse (value, "i", &(object->lay)));
483         if (StringEqual (name, "parent"))
484         {
485                 printf ("This is not implemented yet.\n");
486                 return (1);
487         }
488         if (StringEqual (name, "track"))
489         {
490                 printf ("This is not implemented yet.\n");
491                 return (1);
492         }
493         if (StringEqual (name, "data"))
494         {
495                 printf ("This is not implemented yet.\n");
496                 return (1);
497         }
498         if (StringEqual (name, "ipo"))
499         {
500                 printf ("This is not implemented yet.\n");
501                 return (1);
502         }
503         if (StringEqual (name, "mat"))
504         {
505                 printf ("This is not implemented yet. (matrix)\n");
506                 return (1);
507         }
508         if (StringEqual (name, "matrix"))
509         {
510                 printf ("This is not implemented yet. (matrix)\n");
511                 return (1);
512         }
513         if (StringEqual (name, "colbits"))
514         {
515                 printf ("This is not implemented yet.\n");
516                 return (1);
517         }
518         if (StringEqual (name, "drawType"))
519         {
520                 printf ("This is not implemented yet.\n");
521                 return (1);
522         }
523         if (StringEqual (name, "drawMode"))
524         {
525                 printf ("This is not implemented yet.\n");
526                 return (1);
527         }
528
529         printf ("Unknown variable.\n");
530         return (0);
531 }
532