diff --git a/source/blender/python/api2_2x/Bone.c b/source/blender/python/api2_2x/Bone.c
index 226ce3b2898d8978d39d25d1e4af41e9d84e2313..c0dade51140be095da2973aeae2020316d5d4325 100644
--- a/source/blender/python/api2_2x/Bone.c
+++ b/source/blender/python/api2_2x/Bone.c
@@ -17,7 +17,7 @@
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
@@ -43,37 +43,37 @@
/*****************************************************************************/
-/* Python API function prototypes for the Bone module. */
+/* Python API function prototypes for the Bone module. */
/*****************************************************************************/
static PyObject *M_Bone_New(PyObject *self, PyObject *args, PyObject *keywords);
/*****************************************************************************/
-/* The following string definitions are used for documentation strings. */
-/* In Python these will be written to the console when doing a */
-/* Blender.Armature.Bone.__doc__ */
+/* The following string definitions are used for documentation strings. */
+/* In Python these will be written to the console when doing a */
+/* Blender.Armature.Bone.__doc__ */
/*****************************************************************************/
char M_Bone_doc[] =
"The Blender Bone module\n\n\
This module provides control over **Bone Data** objects in Blender.\n\n\
Example::\n\n\
- from Blender import Armature.Bone\n\
- l = Armature.Bone.New()\n";
+ from Blender import Armature.Bone\n\
+ l = Armature.Bone.New()\n";
char M_Bone_New_doc[] =
"(name) - return a new Bone of name 'name'.";
/*****************************************************************************/
-/* Python method structure definition for Blender.Armature.Bone module: */
+/* Python method structure definition for Blender.Armature.Bone module: */
/*****************************************************************************/
struct PyMethodDef M_Bone_methods[] = {
- {"New",(PyCFunction)M_Bone_New, METH_VARARGS|METH_KEYWORDS,M_Bone_New_doc},
- {NULL, NULL, 0, NULL}
+ {"New",(PyCFunction)M_Bone_New, METH_VARARGS|METH_KEYWORDS,M_Bone_New_doc},
+ {NULL, NULL, 0, NULL}
};
/*****************************************************************************/
-/* Python BPy_Bone methods declarations: */
+/* Python BPy_Bone methods declarations: */
/*****************************************************************************/
static PyObject *Bone_getName(BPy_Bone *self);
static PyObject *Bone_getRoll(BPy_Bone *self);
@@ -96,45 +96,45 @@ static PyObject *Bone_setQuat(BPy_Bone *self, PyObject *args);
//static PyObject *Bone_setChildren(BPy_Bone *self, PyObject *args);
/*****************************************************************************/
-/* Python BPy_Bone methods table: */
+/* Python BPy_Bone methods table: */
/*****************************************************************************/
static PyMethodDef BPy_Bone_methods[] = {
/* name, method, flags, doc */
- {"getName", (PyCFunction)Bone_getName, METH_NOARGS, "() - return Bone name"},
- {"getRoll", (PyCFunction)Bone_getRoll, METH_NOARGS, "() - return Bone roll"},
- {"getHead", (PyCFunction)Bone_getHead, METH_NOARGS, "() - return Bone head"},
- {"getTail", (PyCFunction)Bone_getTail, METH_NOARGS, "() - return Bone tail"},
- {"getLoc", (PyCFunction)Bone_getLoc, METH_NOARGS, "() - return Bone loc"},
- {"getSize", (PyCFunction)Bone_getSize, METH_NOARGS, "() - return Bone size"},
- {"getQuat", (PyCFunction)Bone_getQuat, METH_NOARGS, "() - return Bone quat"},
- {"getParent", (PyCFunction)Bone_hasParent, METH_NOARGS,
- "() - return the parent bone of this one if it exists."
- " None if not found. You can check this condition with the "
- "hasParent() method."},
- {"hasParent", (PyCFunction)Bone_hasParent, METH_NOARGS,
- "() - return true if bone has a parent"},
- {"getChildren", (PyCFunction)Bone_getChildren, METH_NOARGS,
- "() - return Bone children list"},
- {"setName", (PyCFunction)Bone_setName, METH_VARARGS, "(str) - rename Bone"},
- {"setRoll", (PyCFunction)Bone_setRoll, METH_VARARGS,
- "(float) - set Bone roll"},
- {"setHead", (PyCFunction)Bone_setHead, METH_VARARGS,
- "(float,float,float) - set Bone head pos"},
- {"setTail", (PyCFunction)Bone_setTail, METH_VARARGS,
- "(float,float,float) - set Bone tail pos"},
- {"setLoc", (PyCFunction)Bone_setLoc, METH_VARARGS,
- "(float,float,float) - set Bone loc"},
- {"setSize", (PyCFunction)Bone_setSize, METH_VARARGS,
- "(float,float,float) - set Bone size"},
- {"setQuat", (PyCFunction)Bone_setQuat, METH_VARARGS,
- "(float,float,float,float) - set Bone quat"},
- /* {"setParent", (PyCFunction)Bone_setParent, METH_NOARGS, "() - set the Bone parent of this one."},
- {"setChildren", (PyCFunction)Bone_setChildren, METH_NOARGS, "() - replace the children list of the bone."},*/
- {0}
+ {"getName", (PyCFunction)Bone_getName, METH_NOARGS, "() - return Bone name"},
+ {"getRoll", (PyCFunction)Bone_getRoll, METH_NOARGS, "() - return Bone roll"},
+ {"getHead", (PyCFunction)Bone_getHead, METH_NOARGS, "() - return Bone head"},
+ {"getTail", (PyCFunction)Bone_getTail, METH_NOARGS, "() - return Bone tail"},
+ {"getLoc", (PyCFunction)Bone_getLoc, METH_NOARGS, "() - return Bone loc"},
+ {"getSize", (PyCFunction)Bone_getSize, METH_NOARGS, "() - return Bone size"},
+ {"getQuat", (PyCFunction)Bone_getQuat, METH_NOARGS, "() - return Bone quat"},
+ {"getParent", (PyCFunction)Bone_getParent, METH_NOARGS,
+ "() - return the parent bone of this one if it exists."
+ " None if not found. You can check this condition with the "
+ "hasParent() method."},
+ {"hasParent", (PyCFunction)Bone_hasParent, METH_NOARGS,
+ "() - return true if bone has a parent"},
+ {"getChildren", (PyCFunction)Bone_getChildren, METH_NOARGS,
+ "() - return Bone children list"},
+ {"setName", (PyCFunction)Bone_setName, METH_VARARGS, "(str) - rename Bone"},
+ {"setRoll", (PyCFunction)Bone_setRoll, METH_VARARGS,
+ "(float) - set Bone roll"},
+ {"setHead", (PyCFunction)Bone_setHead, METH_VARARGS,
+ "(float,float,float) - set Bone head pos"},
+ {"setTail", (PyCFunction)Bone_setTail, METH_VARARGS,
+ "(float,float,float) - set Bone tail pos"},
+ {"setLoc", (PyCFunction)Bone_setLoc, METH_VARARGS,
+ "(float,float,float) - set Bone loc"},
+ {"setSize", (PyCFunction)Bone_setSize, METH_VARARGS,
+ "(float,float,float) - set Bone size"},
+ {"setQuat", (PyCFunction)Bone_setQuat, METH_VARARGS,
+ "(float,float,float,float) - set Bone quat"},
+ /* {"setParent", (PyCFunction)Bone_setParent, METH_NOARGS, "() - set the Bone parent of this one."},
+ {"setChildren", (PyCFunction)Bone_setChildren, METH_NOARGS, "() - replace the children list of the bone."},*/
+ {0}
};
/*****************************************************************************/
-/* Python TypeBone callback function prototypes: */
+/* Python TypeBone callback function prototypes: */
/*****************************************************************************/
static void Bone_dealloc (BPy_Bone *bone);
static PyObject *Bone_getAttr (BPy_Bone *bone, char *name);
@@ -143,528 +143,528 @@ static int Bone_compare (BPy_Bone *a1, BPy_Bone *a2);
static PyObject *Bone_repr (BPy_Bone *bone);
/*****************************************************************************/
-/* Python TypeBone structure definition: */
+/* Python TypeBone structure definition: */
/*****************************************************************************/
PyTypeObject Bone_Type =
{
- PyObject_HEAD_INIT(NULL)
- 0, /* ob_size */
- "Blender Bone", /* tp_name */
- sizeof (BPy_Bone), /* tp_basicsize */
- 0, /* tp_itemsize */
- /* methods */
- (destructor)Bone_dealloc, /* tp_dealloc */
- 0, /* tp_print */
- (getattrfunc)Bone_getAttr, /* tp_getattr */
- (setattrfunc)Bone_setAttr, /* tp_setattr */
- (cmpfunc)Bone_compare, /* tp_compare */
- (reprfunc)Bone_repr, /* tp_repr */
- 0, /* tp_as_number */
- 0, /* tp_as_sequence */
- 0, /* tp_as_mapping */
- 0, /* tp_as_hash */
- 0,0,0,0,0,0,
- 0, /* tp_doc */
- 0,0,0,0,0,0,
- BPy_Bone_methods, /* tp_methods */
- 0, /* tp_members */
+ PyObject_HEAD_INIT(NULL)
+ 0, /* ob_size */
+ "Blender Bone", /* tp_name */
+ sizeof (BPy_Bone), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ /* methods */
+ (destructor)Bone_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ (getattrfunc)Bone_getAttr, /* tp_getattr */
+ (setattrfunc)Bone_setAttr, /* tp_setattr */
+ (cmpfunc)Bone_compare, /* tp_compare */
+ (reprfunc)Bone_repr, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_as_hash */
+ 0,0,0,0,0,0,
+ 0, /* tp_doc */
+ 0,0,0,0,0,0,
+ BPy_Bone_methods, /* tp_methods */
+ 0, /* tp_members */
};
/*****************************************************************************/
-/* Function: M_Bone_New */
-/* Python equivalent: Blender.Armature.Bone.New */
+/* Function: M_Bone_New */
+/* Python equivalent: Blender.Armature.Bone.New */
/*****************************************************************************/
static PyObject *M_Bone_New(PyObject *self, PyObject *args, PyObject *keywords)
{
- char *name_str = "BoneName";
- BPy_Bone *py_bone = NULL; /* for Bone Data object wrapper in Python */
- Bone *bl_bone = NULL; /* for actual Bone Data we create in Blender */
-
- if (!PyArg_ParseTuple(args, "|s", &name_str))
- return (EXPP_ReturnPyObjError (PyExc_AttributeError,
- "expected string or empty argument"));
-
- // Create the C structure for the newq bone
- bl_bone = (Bone*)malloc(sizeof(Bone));
- strncpy(bl_bone->name,name_str,sizeof(bl_bone->name));
-
- if (bl_bone) /* now create the wrapper obj in Python */
- py_bone = (BPy_Bone *)PyObject_NEW(BPy_Bone, &Bone_Type);
- else
- return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't create Bone Data in Blender"));
-
- if (py_bone == NULL)
- return (EXPP_ReturnPyObjError (PyExc_MemoryError,
- "couldn't create Bone Data object"));
-
- py_bone->bone = bl_bone; /* link Python bone wrapper with Blender Bone */
-
- if (strcmp(name_str, "BoneData") == 0)
- return (PyObject *)py_bone;
- else { /* user gave us a name for the bone, use it */
- // TODO: check that name is not already in use?
- PyOS_snprintf(bl_bone->name, sizeof(bl_bone->name), "%s", name_str);
- }
-
- return (PyObject *)py_bone;
+ char *name_str = "BoneName";
+ BPy_Bone *py_bone = NULL; /* for Bone Data object wrapper in Python */
+ Bone *bl_bone = NULL; /* for actual Bone Data we create in Blender */
+
+ if (!PyArg_ParseTuple(args, "|s", &name_str))
+ return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+ "expected string or empty argument"));
+
+ // Create the C structure for the newq bone
+ bl_bone = (Bone*)malloc(sizeof(Bone));
+ strncpy(bl_bone->name,name_str,sizeof(bl_bone->name));
+
+ if (bl_bone) /* now create the wrapper obj in Python */
+ py_bone = (BPy_Bone *)PyObject_NEW(BPy_Bone, &Bone_Type);
+ else
+ return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't create Bone Data in Blender"));
+
+ if (py_bone == NULL)
+ return (EXPP_ReturnPyObjError (PyExc_MemoryError,
+ "couldn't create Bone Data object"));
+
+ py_bone->bone = bl_bone; /* link Python bone wrapper with Blender Bone */
+
+ if (strcmp(name_str, "BoneData") == 0)
+ return (PyObject *)py_bone;
+ else { /* user gave us a name for the bone, use it */
+ // TODO: check that name is not already in use?
+ PyOS_snprintf(bl_bone->name, sizeof(bl_bone->name), "%s", name_str);
+ }
+
+ return (PyObject *)py_bone;
}
/*****************************************************************************/
-/* Function: Bone_Init */
+/* Function: Bone_Init */
/*****************************************************************************/
PyObject *Bone_Init (void)
{
- PyObject *submodule;
+ PyObject *submodule;
- Bone_Type.ob_type = &PyType_Type;
+ Bone_Type.ob_type = &PyType_Type;
- submodule = Py_InitModule3("Blender.Armature.Bone",
- M_Bone_methods, M_Bone_doc);
+ submodule = Py_InitModule3("Blender.Armature.Bone",
+ M_Bone_methods, M_Bone_doc);
- return (submodule);
+ return (submodule);
}
/*****************************************************************************/
-/* Python BPy_Bone methods: */
+/* Python BPy_Bone methods: */
/*****************************************************************************/
static PyObject *Bone_getName(BPy_Bone *self)
{
- PyObject *attr=NULL;
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- attr = PyString_FromString(self->bone->name);
+ PyObject *attr=NULL;
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ attr = PyString_FromString(self->bone->name);
- if (attr) return attr;
+ if (attr) return attr;
- return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Bone.name attribute"));
+ return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Bone.name attribute"));
}
static PyObject *Bone_getRoll(BPy_Bone *self)
{
- PyObject *attr=NULL;
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- attr = Py_BuildValue("f", self->bone->roll);
+ PyObject *attr=NULL;
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ attr = Py_BuildValue("f", self->bone->roll);
- if (attr) return attr;
+ if (attr) return attr;
- return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Bone.roll attribute"));
+ return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Bone.roll attribute"));
}
static PyObject *Bone_getHead(BPy_Bone *self)
{
- PyObject *attr=NULL;
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- attr = Py_BuildValue("[fff]", self->bone->head[0],self->bone->head[1],
- self->bone->head[2]);
-
- if (attr) return attr;
-
- return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Bone.head attribute"));
+ PyObject *attr=NULL;
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ attr = Py_BuildValue("[fff]", self->bone->head[0],self->bone->head[1],
+ self->bone->head[2]);
+
+ if (attr) return attr;
+
+ return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Bone.head attribute"));
}
static PyObject *Bone_getTail(BPy_Bone *self)
{
- PyObject *attr=NULL;
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- attr = Py_BuildValue("[fff]", self->bone->tail[0],self->bone->tail[1],
- self->bone->tail[2]);
-
- if (attr) return attr;
-
- return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Bone.tail attribute"));
+ PyObject *attr=NULL;
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ attr = Py_BuildValue("[fff]", self->bone->tail[0],self->bone->tail[1],
+ self->bone->tail[2]);
+
+ if (attr) return attr;
+
+ return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Bone.tail attribute"));
}
static PyObject *Bone_getLoc (BPy_Bone *self)
{
- PyObject *attr=NULL;
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- attr = Py_BuildValue("[fff]", self->bone->loc[0],self->bone->loc[1],
- self->bone->loc[2]);
-
- if (attr) return attr;
-
- return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Bone.loc attribute"));
+ PyObject *attr=NULL;
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ attr = Py_BuildValue("[fff]", self->bone->loc[0],self->bone->loc[1],
+ self->bone->loc[2]);
+
+ if (attr) return attr;
+
+ return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Bone.loc attribute"));
}
static PyObject *Bone_getSize(BPy_Bone *self)
{
- PyObject *attr=NULL;
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- attr = Py_BuildValue("[fff]", self->bone->size[0],self->bone->size[1],
- self->bone->size[2]);
-
- if (attr) return attr;
-
- return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Bone.size attribute"));
+ PyObject *attr=NULL;
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ attr = Py_BuildValue("[fff]", self->bone->size[0],self->bone->size[1],
+ self->bone->size[2]);
+
+ if (attr) return attr;
+
+ return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Bone.size attribute"));
}
static PyObject *Bone_getQuat(BPy_Bone *self)
{
- PyObject *attr=NULL;
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- attr = Py_BuildValue("[ffff]", self->bone->quat[0],self->bone->quat[1],
- self->bone->quat[2],self->bone->quat[3]);
-
- if (attr) return attr;
-
- return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Bone.tail attribute"));
+ PyObject *attr=NULL;
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ attr = Py_BuildValue("[ffff]", self->bone->quat[0],self->bone->quat[1],
+ self->bone->quat[2],self->bone->quat[3]);
+
+ if (attr) return attr;
+
+ return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Bone.tail attribute"));
}
static PyObject *Bone_hasParent(BPy_Bone *self)
{
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- /*
- return Bone_CreatePyObject(self->bone->parent);
- */
- if (self->bone->parent)
- {
- Py_INCREF(Py_True);
- return Py_True;
- }
- else
- {
- Py_INCREF(Py_False);
- return Py_False;
- }
-
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ /*
+ return Bone_CreatePyObject(self->bone->parent);
+ */
+ if (self->bone->parent)
+ {
+ Py_INCREF(Py_True);
+ return Py_True;
+ }
+ else
+ {
+ Py_INCREF(Py_False);
+ return Py_False;
+ }
+
}
static PyObject *Bone_getParent(BPy_Bone *self)
{
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- if (self->bone->parent) return Bone_CreatePyObject(self->bone->parent);
- else /*(EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get parent bone, because bone hasn't got a parent."));*/
- {
- Py_INCREF(Py_None);
- return Py_None;
- }
-
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ if (self->bone->parent) return Bone_CreatePyObject(self->bone->parent);
+ else /*(EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get parent bone, because bone hasn't got a parent."));*/
+ {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
+
}
static PyObject *Bone_getChildren(BPy_Bone *self)
{
- int totbones = 0;
- Bone* current = NULL;
- PyObject *listbones = NULL;
- int i;
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- /* Count the number of bones to create the list */
- current = self->bone->childbase.first;
- for (;current; current=current->next) totbones++;
-
- /* Create a list with a bone wrapper for each bone */
- current = self->bone->childbase.first;
- listbones = PyList_New(totbones);
- for (i=0; i<totbones; i++) {
- assert(current);
- PyList_SetItem(listbones, i, Bone_CreatePyObject(current));
- current = current->next;
- }
-
- return listbones;
+ int totbones = 0;
+ Bone* current = NULL;
+ PyObject *listbones = NULL;
+ int i;
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ /* Count the number of bones to create the list */
+ current = self->bone->childbase.first;
+ for (;current; current=current->next) totbones++;
+
+ /* Create a list with a bone wrapper for each bone */
+ current = self->bone->childbase.first;
+ listbones = PyList_New(totbones);
+ for (i=0; i<totbones; i++) {
+ assert(current);
+ PyList_SetItem(listbones, i, Bone_CreatePyObject(current));
+ current = current->next;
+ }
+
+ return listbones;
}
static PyObject *Bone_setName(BPy_Bone *self, PyObject *args)
{
- char *name;
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- if (!PyArg_ParseTuple(args, "s", &name))
- return (EXPP_ReturnPyObjError (PyExc_AttributeError,
- "expected string argument"));
-
- PyOS_snprintf(self->bone->name, sizeof(self->bone->name), "%s", name);
-
- Py_INCREF(Py_None);
- return Py_None;
+ char *name;
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ if (!PyArg_ParseTuple(args, "s", &name))
+ return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+ "expected string argument"));
+
+ PyOS_snprintf(self->bone->name, sizeof(self->bone->name), "%s", name);
+
+ Py_INCREF(Py_None);
+ return Py_None;
}
PyObject *Bone_setRoll(BPy_Bone *self, PyObject *args)
{
- float roll;
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- if (!PyArg_ParseTuple(args, "f", &roll))
- return (EXPP_ReturnPyObjError (PyExc_AttributeError,
- "expected float argument"));
-
- self->bone->roll = roll;
-
- Py_INCREF(Py_None);
- return Py_None;
+ float roll;
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ if (!PyArg_ParseTuple(args, "f", &roll))
+ return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+ "expected float argument"));
+
+ self->bone->roll = roll;
+
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *Bone_setHead(BPy_Bone *self, PyObject *args)
{
- float f1,f2,f3;
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- if (!PyArg_ParseTuple(args, "fff", &f1,&f2,&f3))
- return (EXPP_ReturnPyObjError (PyExc_AttributeError,
- "expected 3 float arguments"));
-
- self->bone->head[0] = f1;
- self->bone->head[1] = f2;
- self->bone->head[2] = f3;
-
- Py_INCREF(Py_None);
- return Py_None;
+ float f1,f2,f3;
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ if (!PyArg_ParseTuple(args, "fff", &f1,&f2,&f3))
+ return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+ "expected 3 float arguments"));
+
+ self->bone->head[0] = f1;
+ self->bone->head[1] = f2;
+ self->bone->head[2] = f3;
+
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *Bone_setTail(BPy_Bone *self, PyObject *args)
{
- float f1,f2,f3;
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- if (!PyArg_ParseTuple(args, "fff", &f1,&f2,&f3))
- return (EXPP_ReturnPyObjError (PyExc_AttributeError,
- "expected 3 float arguments"));
-
- self->bone->tail[0] = f1;
- self->bone->tail[1] = f2;
- self->bone->tail[2] = f3;
-
- Py_INCREF(Py_None);
- return Py_None;
+ float f1,f2,f3;
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ if (!PyArg_ParseTuple(args, "fff", &f1,&f2,&f3))
+ return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+ "expected 3 float arguments"));
+
+ self->bone->tail[0] = f1;
+ self->bone->tail[1] = f2;
+ self->bone->tail[2] = f3;
+
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *Bone_setLoc(BPy_Bone *self, PyObject *args)
{
- float f1,f2,f3;
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- if (!PyArg_ParseTuple(args, "fff", &f1,&f2,&f3))
- return (EXPP_ReturnPyObjError (PyExc_AttributeError,
- "expected 3 float arguments"));
-
- self->bone->loc[0] = f1;
- self->bone->loc[1] = f2;
- self->bone->loc[2] = f3;
-
- Py_INCREF(Py_None);
- return Py_None;
+ float f1,f2,f3;
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ if (!PyArg_ParseTuple(args, "fff", &f1,&f2,&f3))
+ return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+ "expected 3 float arguments"));
+
+ self->bone->loc[0] = f1;
+ self->bone->loc[1] = f2;
+ self->bone->loc[2] = f3;
+
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *Bone_setSize(BPy_Bone *self, PyObject *args)
{
- float f1,f2,f3;
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- if (!PyArg_ParseTuple(args, "fff", &f1,&f2,&f3))
- return (EXPP_ReturnPyObjError (PyExc_AttributeError,
- "expected 3 float arguments"));
-
- self->bone->size[0] = f1;
- self->bone->size[1] = f2;
- self->bone->size[2] = f3;
-
- Py_INCREF(Py_None);
- return Py_None;
+ float f1,f2,f3;
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ if (!PyArg_ParseTuple(args, "fff", &f1,&f2,&f3))
+ return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+ "expected 3 float arguments"));
+
+ self->bone->size[0] = f1;
+ self->bone->size[1] = f2;
+ self->bone->size[2] = f3;
+
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *Bone_setQuat(BPy_Bone *self, PyObject *args)
{
- float f1,f2,f3,f4;
-
- if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get attribute from a NULL bone"));
-
- if (!PyArg_ParseTuple(args, "ffff", &f1,&f2,&f3,&f4))
- return (EXPP_ReturnPyObjError (PyExc_AttributeError,
- "expected 4 float arguments"));
-
- self->bone->quat[0] = f1;
- self->bone->quat[1] = f2;
- self->bone->quat[2] = f3;
- self->bone->quat[3] = f4;
-
- Py_INCREF(Py_None);
- return Py_None;
+ float f1,f2,f3,f4;
+
+ if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get attribute from a NULL bone"));
+
+ if (!PyArg_ParseTuple(args, "ffff", &f1,&f2,&f3,&f4))
+ return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+ "expected 4 float arguments"));
+
+ self->bone->quat[0] = f1;
+ self->bone->quat[1] = f2;
+ self->bone->quat[2] = f3;
+ self->bone->quat[3] = f4;
+
+ Py_INCREF(Py_None);
+ return Py_None;
}
/*****************************************************************************/
-/* Function: Bone_dealloc */
-/* Description: This is a callback function for the BPy_Bone type. It is */
-/* the destructor function. */
+/* Function: Bone_dealloc */
+/* Description: This is a callback function for the BPy_Bone type. It is */
+/* the destructor function. */
/*****************************************************************************/
static void Bone_dealloc (BPy_Bone *self)
{
- PyObject_DEL (self);
+ PyObject_DEL (self);
}
/*****************************************************************************/
-/* Function: Bone_getAttr */
-/* Description: This is a callback function for the BPy_Bone type. It is */
-/* the function that accesses BPy_Bone member variables and */
-/* methods. */
+/* Function: Bone_getAttr */
+/* Description: This is a callback function for the BPy_Bone type. It is */
+/* the function that accesses BPy_Bone member variables and */
+/* methods. */
/*****************************************************************************/
static PyObject* Bone_getAttr (BPy_Bone *self, char *name)
{
- PyObject *attr = Py_None;
-
- if (strcmp(name, "name") == 0)
- attr = Bone_getName(self);
- else if (strcmp(name, "roll") == 0)
- attr = Bone_getRoll(self);
- else if (strcmp(name, "head") == 0)
- attr = Bone_getHead(self);
- else if (strcmp(name, "tail") == 0)
- attr = Bone_getTail(self);
- else if (strcmp(name, "size") == 0)
- attr = Bone_getSize(self);
- else if (strcmp(name, "loc") == 0)
- attr = Bone_getLoc(self);
- else if (strcmp(name, "quat") == 0)
- attr = Bone_getQuat(self);
- else if (strcmp(name, "parent") == 0)
- // Skip the checks for Py_None as its a valid result to this call.
- return Bone_getParent(self);
- else if (strcmp(name, "children") == 0)
- attr = Bone_getChildren(self);
- else if (strcmp(name, "__members__") == 0) {
- /* 9 entries */
- attr = Py_BuildValue("[s,s,s,s,s,s,s,s,s]",
- "name","roll","head","tail","loc","size",
- "quat","parent","children");
- }
-
- if (!attr)
- return (EXPP_ReturnPyObjError (PyExc_MemoryError,
- "couldn't create PyObject"));
-
- if (attr != Py_None) return attr; /* member attribute found, return it */
-
- /* not an attribute, search the methods table */
- return Py_FindMethod(BPy_Bone_methods, (PyObject *)self, name);
+ PyObject *attr = Py_None;
+
+ if (strcmp(name, "name") == 0)
+ attr = Bone_getName(self);
+ else if (strcmp(name, "roll") == 0)
+ attr = Bone_getRoll(self);
+ else if (strcmp(name, "head") == 0)
+ attr = Bone_getHead(self);
+ else if (strcmp(name, "tail") == 0)
+ attr = Bone_getTail(self);
+ else if (strcmp(name, "size") == 0)
+ attr = Bone_getSize(self);
+ else if (strcmp(name, "loc") == 0)
+ attr = Bone_getLoc(self);
+ else if (strcmp(name, "quat") == 0)
+ attr = Bone_getQuat(self);
+ else if (strcmp(name, "parent") == 0)
+ // Skip the checks for Py_None as its a valid result to this call.
+ return Bone_getParent(self);
+ else if (strcmp(name, "children") == 0)
+ attr = Bone_getChildren(self);
+ else if (strcmp(name, "__members__") == 0) {
+ /* 9 entries */
+ attr = Py_BuildValue("[s,s,s,s,s,s,s,s,s]",
+ "name","roll","head","tail","loc","size",
+ "quat","parent","children");
+ }
+
+ if (!attr)
+ return (EXPP_ReturnPyObjError (PyExc_MemoryError,
+ "couldn't create PyObject"));
+
+ if (attr != Py_None) return attr; /* member attribute found, return it */
+
+ /* not an attribute, search the methods table */
+ return Py_FindMethod(BPy_Bone_methods, (PyObject *)self, name);
}
/*****************************************************************************/
-/* Function: Bone_setAttr */
+/* Function: Bone_setAttr */
/* Description: This is a callback function for the BPy_Bone type. It is the */
-/* function that changes Bone Data members values. If this */
-/* data is linked to a Blender Bone, it also gets updated. */
+/* function that changes Bone Data members values. If this */
+/* data is linked to a Blender Bone, it also gets updated. */
/*****************************************************************************/
static int Bone_setAttr (BPy_Bone *self, char *name, PyObject *value)
{
- PyObject *valtuple;
- PyObject *error = NULL;
-
- valtuple = Py_BuildValue("(O)", value); /* the set* functions expect a tuple */
-
- if (!valtuple)
- return EXPP_ReturnIntError(PyExc_MemoryError,
- "BoneSetAttr: couldn't create tuple");
-
- if (strcmp (name, "name") == 0)
- error = Bone_setName (self, valtuple);
- else { /* Error */
- Py_DECREF(valtuple);
-
- /* ... member with the given name was found */
- return (EXPP_ReturnIntError (PyExc_KeyError,
- "attribute not found"));
- }
-
- Py_DECREF(valtuple);
-
- if (error != Py_None) return -1;
-
- Py_DECREF(Py_None); /* was incref'ed by the called Bone_set* function */
- return 0; /* normal exit */
+ PyObject *valtuple;
+ PyObject *error = NULL;
+
+ valtuple = Py_BuildValue("(O)", value); /* the set* functions expect a tuple */
+
+ if (!valtuple)
+ return EXPP_ReturnIntError(PyExc_MemoryError,
+ "BoneSetAttr: couldn't create tuple");
+
+ if (strcmp (name, "name") == 0)
+ error = Bone_setName (self, valtuple);
+ else { /* Error */
+ Py_DECREF(valtuple);
+
+ /* ... member with the given name was found */
+ return (EXPP_ReturnIntError (PyExc_KeyError,
+ "attribute not found"));
+ }
+
+ Py_DECREF(valtuple);
+
+ if (error != Py_None) return -1;
+
+ Py_DECREF(Py_None); /* was incref'ed by the called Bone_set* function */
+ return 0; /* normal exit */
}
/*****************************************************************************/
-/* Function: Bone_repr */
-/* Description: This is a callback function for the BPy_Bone type. It */
-/* builds a meaninful string to represent bone objects. */
+/* Function: Bone_repr */
+/* Description: This is a callback function for the BPy_Bone type. It */
+/* builds a meaninful string to represent bone objects. */
/*****************************************************************************/
static PyObject *Bone_repr (BPy_Bone *self)
{
- if (self->bone)
+ if (self->bone)
return PyString_FromFormat("[Bone \"%s\"]", self->bone->name);
- else return PyString_FromString("NULL");
+ else return PyString_FromString("NULL");
}
/**************************************************************************/
-/* Function: Bone_compare */
-/* Description: This is a callback function for the BPy_Bone type. It */
-/* compares the two bones: translate comparison to the */
-/* C pointers. */
+/* Function: Bone_compare */
+/* Description: This is a callback function for the BPy_Bone type. It */
+/* compares the two bones: translate comparison to the */
+/* C pointers. */
/**************************************************************************/
static int Bone_compare (BPy_Bone *a, BPy_Bone *b)
{
- Bone *pa = a->bone, *pb = b->bone;
+ Bone *pa = a->bone, *pb = b->bone;
return (pa == pb) ? 0:-1;
}
@@ -672,43 +672,43 @@ static int Bone_compare (BPy_Bone *a, BPy_Bone *b)
/*****************************************************************************/
-/* Function: Bone_CreatePyObject */
-/* Description: This function will create a new BlenBone from an existing */
-/* Bone structure. */
+/* Function: Bone_CreatePyObject */
+/* Description: This function will create a new BlenBone from an existing */
+/* Bone structure. */
/*****************************************************************************/
PyObject* Bone_CreatePyObject (struct Bone *obj)
{
- BPy_Bone * blen_bone;
+ BPy_Bone * blen_bone;
- blen_bone = (BPy_Bone*)PyObject_NEW (BPy_Bone, &Bone_Type);
+ blen_bone = (BPy_Bone*)PyObject_NEW (BPy_Bone, &Bone_Type);
- if (blen_bone == NULL)
- {
- return (NULL);
- }
- blen_bone->bone = obj;
- return ((PyObject*)blen_bone);
+ if (blen_bone == NULL)
+ {
+ return (NULL);
+ }
+ blen_bone->bone = obj;
+ return ((PyObject*)blen_bone);
}
/*****************************************************************************/
-/* Function: Bone_CheckPyObject */
+/* Function: Bone_CheckPyObject */
/* Description: This function returns true when the given PyObject is of the */
-/* type Bone. Otherwise it will return false. */
+/* type Bone. Otherwise it will return false. */
/*****************************************************************************/
int Bone_CheckPyObject (PyObject *py_obj)
{
- return (py_obj->ob_type == &Bone_Type);
+ return (py_obj->ob_type == &Bone_Type);
}
/*****************************************************************************/
-/* Function: Bone_FromPyObject */
-/* Description: This function returns the Blender bone from the given */
-/* PyObject. */
+/* Function: Bone_FromPyObject */
+/* Description: This function returns the Blender bone from the given */
+/* PyObject. */
/*****************************************************************************/
struct Bone* Bone_FromPyObject (PyObject *py_obj)
{
- BPy_Bone * blen_obj;
+ BPy_Bone * blen_obj;
- blen_obj = (BPy_Bone*)py_obj;
- return (blen_obj->bone);
+ blen_obj = (BPy_Bone*)py_obj;
+ return (blen_obj->bone);
}
diff --git a/source/blender/python/api2_2x/Material.c b/source/blender/python/api2_2x/Material.c
index f51fd7c4b32dd7da39a0bc70684eb00d29ec0b5e..16195bd73b6cf68c95db8adf11f859b1750659f3 100644
--- a/source/blender/python/api2_2x/Material.c
+++ b/source/blender/python/api2_2x/Material.c
@@ -17,7 +17,7 @@
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
@@ -42,84 +42,85 @@
#include "Material.h"
/*****************************************************************************/
-/* Python BPy_Material defaults: */
+/* Python BPy_Material defaults: */
/*****************************************************************************/
-#define EXPP_MAT_MODE_TRACEABLE MA_TRACEBLE
-#define EXPP_MAT_MODE_SHADOW MA_SHADOW
-#define EXPP_MAT_MODE_SHADELESS MA_SHLESS
-#define EXPP_MAT_MODE_WIRE MA_WIRE
-#define EXPP_MAT_MODE_VCOL_LIGHT MA_VERTEXCOL
-#define EXPP_MAT_MODE_HALO MA_HALO
-#define EXPP_MAT_MODE_ZTRANSP MA_ZTRA
-#define EXPP_MAT_MODE_VCOL_PAINT MA_VERTEXCOLP
-#define EXPP_MAT_MODE_ZINVERT MA_ZINV
-#define EXPP_MAT_MODE_HALORINGS MA_HALO_RINGS
-#define EXPP_MAT_MODE_ENV MA_ENV
-#define EXPP_MAT_MODE_HALOLINES MA_HALO_LINES
-#define EXPP_MAT_MODE_ONLYSHADOW MA_ONLYSHADOW
-#define EXPP_MAT_MODE_HALOXALPHA MA_HALO_XALPHA
-#define EXPP_MAT_MODE_HALOSTAR MA_STAR
-#define EXPP_MAT_MODE_TEXFACE MA_FACETEXTURE
-#define EXPP_MAT_MODE_HALOTEX MA_HALOTEX
-#define EXPP_MAT_MODE_HALOPUNO MA_HALOPUNO
-#define EXPP_MAT_MODE_NOMIST MA_NOMIST
-#define EXPP_MAT_MODE_HALOSHADE MA_HALO_SHADE
-#define EXPP_MAT_MODE_HALOFLARE MA_HALO_FLARE
+#define EXPP_MAT_MODE_TRACEABLE MA_TRACEBLE
+#define EXPP_MAT_MODE_SHADOW MA_SHADOW
+#define EXPP_MAT_MODE_SHADELESS MA_SHLESS
+#define EXPP_MAT_MODE_WIRE MA_WIRE
+#define EXPP_MAT_MODE_VCOL_LIGHT MA_VERTEXCOL
+#define EXPP_MAT_MODE_HALO MA_HALO
+#define EXPP_MAT_MODE_ZTRANSP MA_ZTRA
+#define EXPP_MAT_MODE_VCOL_PAINT MA_VERTEXCOLP
+#define EXPP_MAT_MODE_ZINVERT MA_ZINV
+#define EXPP_MAT_MODE_HALORINGS MA_HALO_RINGS
+#define EXPP_MAT_MODE_ENV MA_ENV
+#define EXPP_MAT_MODE_HALOLINES MA_HALO_LINES
+#define EXPP_MAT_MODE_ONLYSHADOW MA_ONLYSHADOW
+#define EXPP_MAT_MODE_HALOXALPHA MA_HALO_XALPHA
+#define EXPP_MAT_MODE_HALOSTAR MA_STAR
+#define EXPP_MAT_MODE_TEXFACE MA_FACETEXTURE
+#define EXPP_MAT_MODE_HALOTEX MA_HALOTEX
+#define EXPP_MAT_MODE_HALOPUNO MA_HALOPUNO
+#define EXPP_MAT_MODE_NOMIST MA_NOMIST
+#define EXPP_MAT_MODE_HALOSHADE MA_HALO_SHADE
+#define EXPP_MAT_MODE_HALOFLARE MA_HALO_FLARE
+#define EXPP_MAT_MODE_RADIO MA_RADIO
/* Material MIN, MAX values */
-#define EXPP_MAT_ADD_MIN 0.0
-#define EXPP_MAT_ADD_MAX 1.0
-#define EXPP_MAT_ALPHA_MIN 0.0
-#define EXPP_MAT_ALPHA_MAX 1.0
-#define EXPP_MAT_AMB_MIN 0.0
-#define EXPP_MAT_AMB_MAX 1.0
-#define EXPP_MAT_COL_MIN 0.0 /* min/max for all ... */
-#define EXPP_MAT_COL_MAX 1.0 /* ... color triplets */
-#define EXPP_MAT_EMIT_MIN 0.0
-#define EXPP_MAT_EMIT_MAX 1.0
-#define EXPP_MAT_REF_MIN 0.0
-#define EXPP_MAT_REF_MAX 1.0
-#define EXPP_MAT_SPEC_MIN 0.0
-#define EXPP_MAT_SPEC_MAX 2.0
-#define EXPP_MAT_SPECTRA_MIN 0.0
-#define EXPP_MAT_SPECTRA_MAX 1.0
-#define EXPP_MAT_ZOFFS_MIN 0.0
-#define EXPP_MAT_ZOFFS_MAX 10.0
-#define EXPP_MAT_HALOSIZE_MIN 0.0
-#define EXPP_MAT_HALOSIZE_MAX 100.0
-#define EXPP_MAT_FLARESIZE_MIN 0.1
-#define EXPP_MAT_FLARESIZE_MAX 25.0
-#define EXPP_MAT_FLAREBOOST_MIN 0.1
-#define EXPP_MAT_FLAREBOOST_MAX 10.0
-#define EXPP_MAT_SUBSIZE_MIN 0.1
-#define EXPP_MAT_SUBSIZE_MAX 25.0
-
-#define EXPP_MAT_HARD_MIN 1
-#define EXPP_MAT_HARD_MAX 255 /* 127 with MODE HALO ON */
-#define EXPP_MAT_HALOSEED_MIN 1
+#define EXPP_MAT_ADD_MIN 0.0
+#define EXPP_MAT_ADD_MAX 1.0
+#define EXPP_MAT_ALPHA_MIN 0.0
+#define EXPP_MAT_ALPHA_MAX 1.0
+#define EXPP_MAT_AMB_MIN 0.0
+#define EXPP_MAT_AMB_MAX 1.0
+#define EXPP_MAT_COL_MIN 0.0 /* min/max for all ... */
+#define EXPP_MAT_COL_MAX 1.0 /* ... color triplets */
+#define EXPP_MAT_EMIT_MIN 0.0
+#define EXPP_MAT_EMIT_MAX 1.0
+#define EXPP_MAT_REF_MIN 0.0
+#define EXPP_MAT_REF_MAX 1.0
+#define EXPP_MAT_SPEC_MIN 0.0
+#define EXPP_MAT_SPEC_MAX 2.0
+#define EXPP_MAT_SPECTRA_MIN 0.0
+#define EXPP_MAT_SPECTRA_MAX 1.0
+#define EXPP_MAT_ZOFFS_MIN 0.0
+#define EXPP_MAT_ZOFFS_MAX 10.0
+#define EXPP_MAT_HALOSIZE_MIN 0.0
+#define EXPP_MAT_HALOSIZE_MAX 100.0
+#define EXPP_MAT_FLARESIZE_MIN 0.1
+#define EXPP_MAT_FLARESIZE_MAX 25.0
+#define EXPP_MAT_FLAREBOOST_MIN 0.1
+#define EXPP_MAT_FLAREBOOST_MAX 10.0
+#define EXPP_MAT_SUBSIZE_MIN 0.1
+#define EXPP_MAT_SUBSIZE_MAX 25.0
+
+#define EXPP_MAT_HARD_MIN 1
+#define EXPP_MAT_HARD_MAX 255 /* 127 with MODE HALO ON */
+#define EXPP_MAT_HALOSEED_MIN 1
#define EXPP_MAT_HALOSEED_MAX 255
-#define EXPP_MAT_NFLARES_MIN 1
-#define EXPP_MAT_NFLARES_MAX 32
-#define EXPP_MAT_FLARESEED_MIN 1
+#define EXPP_MAT_NFLARES_MIN 1
+#define EXPP_MAT_NFLARES_MAX 32
+#define EXPP_MAT_FLARESEED_MIN 1
#define EXPP_MAT_FLARESEED_MAX 255
-#define EXPP_MAT_NSTARS_MIN 3
-#define EXPP_MAT_NSTARS_MAX 50
-#define EXPP_MAT_NLINES_MIN 0
-#define EXPP_MAT_NLINES_MAX 250
-#define EXPP_MAT_NRINGS_MIN 0
-#define EXPP_MAT_NRINGS_MAX 24
+#define EXPP_MAT_NSTARS_MIN 3
+#define EXPP_MAT_NSTARS_MAX 50
+#define EXPP_MAT_NLINES_MIN 0
+#define EXPP_MAT_NLINES_MAX 250
+#define EXPP_MAT_NRINGS_MIN 0
+#define EXPP_MAT_NRINGS_MAX 24
/*****************************************************************************/
-/* Python API function prototypes for the Material module. */
+/* Python API function prototypes for the Material module. */
/*****************************************************************************/
static PyObject *M_Material_New (PyObject *self, PyObject *args,
- PyObject *keywords);
+ PyObject *keywords);
static PyObject *M_Material_Get (PyObject *self, PyObject *args);
/*****************************************************************************/
-/* The following string definitions are used for documentation strings. */
-/* In Python these will be written to the console when doing a */
-/* Blender.Material.__doc__ */
+/* The following string definitions are used for documentation strings. */
+/* In Python these will be written to the console when doing a */
+/* Blender.Material.__doc__ */
/*****************************************************************************/
static char M_Material_doc[] =
"The Blender Material module";
@@ -133,119 +134,119 @@ static char M_Material_Get_doc[] =
() - return a list of all materials in the current scene.";
/*****************************************************************************/
-/* Python method structure definition for Blender.Material module: */
+/* Python method structure definition for Blender.Material module: */
/*****************************************************************************/
struct PyMethodDef M_Material_methods[] = {
- {"New",(PyCFunction)M_Material_New, METH_VARARGS|METH_KEYWORDS,
- M_Material_New_doc},
- {"Get", M_Material_Get, METH_VARARGS, M_Material_Get_doc},
- {"get", M_Material_Get, METH_VARARGS, M_Material_Get_doc},
- {NULL, NULL, 0, NULL}
+ {"New",(PyCFunction)M_Material_New, METH_VARARGS|METH_KEYWORDS,
+ M_Material_New_doc},
+ {"Get", M_Material_Get, METH_VARARGS, M_Material_Get_doc},
+ {"get", M_Material_Get, METH_VARARGS, M_Material_Get_doc},
+ {NULL, NULL, 0, NULL}
};
/*****************************************************************************/
-/* Function: M_Material_New */
-/* Python equivalent: Blender.Material.New */
+/* Function: M_Material_New */
+/* Python equivalent: Blender.Material.New */
/*****************************************************************************/
static PyObject *M_Material_New(PyObject *self, PyObject *args,
PyObject *keywords)
{
- char *name = "Mat";
- static char *kwlist[] = {"name", NULL};
- BPy_Material *pymat; /* for Material Data object wrapper in Python */
- Material *blmat; /* for actual Material Data we create in Blender */
- char buf[21];
+ char *name = "Mat";
+ static char *kwlist[] = {"name", NULL};
+ BPy_Material *pymat; /* for Material Data object wrapper in Python */
+ Material *blmat; /* for actual Material Data we create in Blender */
+ char buf[21];
- if (!PyArg_ParseTupleAndKeywords(args, keywords, "|s", kwlist, &name))
- return (EXPP_ReturnPyObjError (PyExc_AttributeError,
- "expected string or nothing as argument"));
+ if (!PyArg_ParseTupleAndKeywords(args, keywords, "|s", kwlist, &name))
+ return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+ "expected string or nothing as argument"));
- if (strcmp(name, "Mat") != 0) /* use gave us a name ?*/
- PyOS_snprintf(buf, sizeof(buf), "%s", name);
+ if (strcmp(name, "Mat") != 0) /* use gave us a name ?*/
+ PyOS_snprintf(buf, sizeof(buf), "%s", name);
- blmat = add_material(name); /* first create the Material Data in Blender */
+ blmat = add_material(name); /* first create the Material Data in Blender */
- if (blmat) /* now create the wrapper obj in Python */
- pymat = (BPy_Material *)Material_CreatePyObject (blmat);
- else
- return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't create Material Data in Blender"));
+ if (blmat) /* now create the wrapper obj in Python */
+ pymat = (BPy_Material *)Material_CreatePyObject (blmat);
+ else
+ return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't create Material Data in Blender"));
- blmat->id.us = 0; /* was incref'ed by add_material() above */
+ blmat->id.us = 0; /* was incref'ed by add_material() above */
- if (pymat == NULL)
- return (EXPP_ReturnPyObjError (PyExc_MemoryError,
- "couldn't create Material Data object"));
+ if (pymat == NULL)
+ return (EXPP_ReturnPyObjError (PyExc_MemoryError,
+ "couldn't create Material Data object"));
- return (PyObject *)pymat;
+ return (PyObject *)pymat;
}
/*****************************************************************************/
-/* Function: M_Material_Get */
-/* Python equivalent: Blender.Material.Get */
-/* Description: Receives a string and returns the material whose */
-/* name matches the string. If no argument is */
-/* passed in, a list with all materials in the */
-/* current scene is returned. */
+/* Function: M_Material_Get */
+/* Python equivalent: Blender.Material.Get */
+/* Description: Receives a string and returns the material whose */
+/* name matches the string. If no argument is */
+/* passed in, a list with all materials in the */
+/* current scene is returned. */
/*****************************************************************************/
static PyObject *M_Material_Get(PyObject *self, PyObject *args)
{
- char *name = NULL;
- Material *mat_iter;
+ char *name = NULL;
+ Material *mat_iter;
- if (!PyArg_ParseTuple(args, "|s", &name))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected string argument (or nothing)"));
+ if (!PyArg_ParseTuple(args, "|s", &name))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected string argument (or nothing)"));
- mat_iter = G.main->mat.first;
+ mat_iter = G.main->mat.first;
- if (name) { /* (name) - Search material by name */
+ if (name) { /* (name) - Search material by name */
- BPy_Material *wanted_mat = NULL;
+ BPy_Material *wanted_mat = NULL;
- while ((mat_iter) && (wanted_mat == NULL)) {
+ while ((mat_iter) && (wanted_mat == NULL)) {
- if (strcmp (name, mat_iter->id.name+2) == 0)
- wanted_mat = (BPy_Material *)Material_CreatePyObject (mat_iter);
+ if (strcmp (name, mat_iter->id.name+2) == 0)
+ wanted_mat = (BPy_Material *)Material_CreatePyObject (mat_iter);
- mat_iter = mat_iter->id.next;
- }
+ mat_iter = mat_iter->id.next;
+ }
- if (wanted_mat == NULL) { /* Requested material doesn't exist */
- char error_msg[64];
- PyOS_snprintf(error_msg, sizeof(error_msg),
- "Material \"%s\" not found", name);
- return (EXPP_ReturnPyObjError (PyExc_NameError, error_msg));
- }
+ if (wanted_mat == NULL) { /* Requested material doesn't exist */
+ char error_msg[64];
+ PyOS_snprintf(error_msg, sizeof(error_msg),
+ "Material \"%s\" not found", name);
+ return (EXPP_ReturnPyObjError (PyExc_NameError, error_msg));
+ }
- return (PyObject *)wanted_mat;
- }
+ return (PyObject *)wanted_mat;
+ }
- else { /* () - return a list with all materials in the scene */
- int index = 0;
- PyObject *matlist, *pyobj;
+ else { /* () - return a list with all materials in the scene */
+ int index = 0;
+ PyObject *matlist, *pyobj;
- matlist = PyList_New (BLI_countlist (&(G.main->mat)));
+ matlist = PyList_New (BLI_countlist (&(G.main->mat)));
- if (!matlist)
- return (PythonReturnErrorObject (PyExc_MemoryError,
- "couldn't create PyList"));
+ if (!matlist)
+ return (PythonReturnErrorObject (PyExc_MemoryError,
+ "couldn't create PyList"));
- while (mat_iter) {
- pyobj = Material_CreatePyObject (mat_iter);
+ while (mat_iter) {
+ pyobj = Material_CreatePyObject (mat_iter);
- if (!pyobj)
- return (PythonReturnErrorObject (PyExc_MemoryError,
- "couldn't create PyObject"));
+ if (!pyobj)
+ return (PythonReturnErrorObject (PyExc_MemoryError,
+ "couldn't create PyObject"));
- PyList_SET_ITEM (matlist, index, pyobj);
+ PyList_SET_ITEM (matlist, index, pyobj);
- mat_iter = mat_iter->id.next;
- index++;
- }
+ mat_iter = mat_iter->id.next;
+ index++;
+ }
- return matlist;
- }
+ return matlist;
+ }
}
static PyObject *Lamp_ModesDict (void)
@@ -285,27 +286,28 @@ static PyObject *Lamp_ModesDict (void)
EXPP_ADDCONST(NOMIST);
EXPP_ADDCONST(HALOSHADE);
EXPP_ADDCONST(HALOFLARE);
+ EXPP_ADDCONST(RADIO);
}
return Modes;
}
/*****************************************************************************/
-/* Function: Material_Init */
+/* Function: Material_Init */
/*****************************************************************************/
PyObject *Material_Init (void)
{
- PyObject *submodule, *Modes;
+ PyObject *submodule, *Modes;
- Material_Type.ob_type = &PyType_Type;
+ Material_Type.ob_type = &PyType_Type;
Modes = Lamp_ModesDict ();
- submodule = Py_InitModule3("Blender.Material",
- M_Material_methods, M_Material_doc);
+ submodule = Py_InitModule3("Blender.Material",
+ M_Material_methods, M_Material_doc);
if (Modes) PyModule_AddObject(submodule, "Modes", Modes);
- return (submodule);
+ return (submodule);
}
/***************************/
@@ -313,7 +315,7 @@ PyObject *Material_Init (void)
/***************************/
/*****************************************************************************/
-/* Python BPy_Material methods declarations: */
+/* Python BPy_Material methods declarations: */
/*****************************************************************************/
static PyObject *Material_getName(BPy_Material *self);
static PyObject *Material_getMode(BPy_Material *self);
@@ -368,121 +370,121 @@ static PyObject *Material_setNLines(BPy_Material *self, PyObject *args);
static PyObject *Material_setNRings(BPy_Material *self, PyObject *args);
static PyObject *Material_setColorComponent(BPy_Material *self, char *key,
- PyObject *args);
+ PyObject *args);
/*****************************************************************************/
-/* Python BPy_Material methods table: */
+/* Python BPy_Material methods table: */
/*****************************************************************************/
static PyMethodDef BPy_Material_methods[] = {
/* name, method, flags, doc */
- {"getName", (PyCFunction)Material_getName, METH_NOARGS,
- "() - Return Material Data name"},
- {"getMode", (PyCFunction)Material_getMode, METH_NOARGS,
- "() - Return Material mode flags"},
- {"getRGBCol", (PyCFunction)Material_getRGBCol, METH_NOARGS,
- "() - Return Material's rgb color triplet"},
-/* {"getAmbCol", (PyCFunction)Material_getAmbCol, METH_NOARGS,
- "() - Return Material's ambient color"},*/
- {"getSpecCol", (PyCFunction)Material_getSpecCol, METH_NOARGS,
- "() - Return Material's specular color"},
- {"getMirCol", (PyCFunction)Material_getMirCol, METH_NOARGS,
- "() - Return Material's mirror color"},
- {"getAmb", (PyCFunction)Material_getAmb, METH_NOARGS,
- "() - Return Material's ambient color blend factor"},
- {"getEmit", (PyCFunction)Material_getEmit, METH_NOARGS,
- "() - Return Material's emitting light intensity"},
- {"getAlpha", (PyCFunction)Material_getAlpha, METH_NOARGS,
- "() - Return Material's alpha (transparency) value"},
- {"getRef", (PyCFunction)Material_getRef, METH_NOARGS,
- "() - Return Material's reflectivity"},
- {"getSpec", (PyCFunction)Material_getSpec, METH_NOARGS,
- "() - Return Material's specularity"},
- {"getSpecTransp", (PyCFunction)Material_getSpecTransp, METH_NOARGS,
- "() - Return Material's specular transparency"},
- {"getAdd", (PyCFunction)Material_getAdd, METH_NOARGS,
- "() - Return Material's glow factor"},
- {"getZOffset", (PyCFunction)Material_getZOffset, METH_NOARGS,
- "() - Return Material's artificial offset for faces"},
- {"getHaloSize", (PyCFunction)Material_getHaloSize, METH_NOARGS,
- "() - Return Material's halo size"},
- {"getHaloSeed", (PyCFunction)Material_getHaloSeed, METH_NOARGS,
- "() - Return Material's seed for random ring dimension and line "
- "location in halos"},
- {"getFlareSize", (PyCFunction)Material_getFlareSize, METH_NOARGS,
- "() - Return Material's (flare size)/(halo size) factor"},
- {"getFlareSeed", (PyCFunction)Material_getFlareSeed, METH_NOARGS,
- "() - Return Material's flare offset in the seed table"},
- {"getFlareBoost", (PyCFunction)Material_getFlareBoost, METH_NOARGS,
- "() - Return Material's flare boost"},
- {"getSubSize", (PyCFunction)Material_getSubSize, METH_NOARGS,
- "() - Return Material's dimension of subflare, dots and circles"},
- {"getHardness", (PyCFunction)Material_getHardness, METH_NOARGS,
- "() - Return Material's specular hardness"},
- {"getNFlares", (PyCFunction)Material_getNFlares, METH_NOARGS,
- "() - Return Material's number of flares in halo"},
- {"getNStars", (PyCFunction)Material_getNStars, METH_NOARGS,
- "() - Return Material's number of points in the halo stars"},
- {"getNLines", (PyCFunction)Material_getNLines, METH_NOARGS,
- "() - Return Material's number of lines in halo"},
- {"getNRings", (PyCFunction)Material_getNRings, METH_NOARGS,
- "() - Return Material's number of rings in halo"},
- {"setName", (PyCFunction)Material_setName, METH_VARARGS,
- "(s) - Change Material Data name"},
- {"setMode", (PyCFunction)Material_setMode, METH_VARARGS,
- "([s[,s]]) - Set Material mode flag(s)"},
- {"setRGBCol", (PyCFunction)Material_setRGBCol, METH_VARARGS,
- "(f,f,f or [f,f,f]) - Set Material's rgb color triplet"},
-/* {"setAmbCol", (PyCFunction)Material_setAmbCol, METH_VARARGS,
- "(f,f,f or [f,f,f]) - Set Material's ambient color"},*/
- {"setSpecCol", (PyCFunction)Material_setSpecCol, METH_VARARGS,
- "(f,f,f or [f,f,f]) - Set Material's specular color"},
- {"setMirCol", (PyCFunction)Material_setMirCol, METH_VARARGS,
- "(f,f,f or [f,f,f]) - Set Material's mirror color"},
- {"setAmb", (PyCFunction)Material_setAmb, METH_VARARGS,
- "(f) - Set how much the Material's color is affected"
- " by \nthe global ambient colors - [0.0, 1.0]"},
- {"setEmit", (PyCFunction)Material_setEmit, METH_VARARGS,
- "(f) - Set Material's emitting light intensity - [0.0, 1.0]"},
- {"setAlpha", (PyCFunction)Material_setAlpha, METH_VARARGS,
- "(f) - Set Material's alpha (transparency) - [0.0, 1.0]"},
- {"setRef", (PyCFunction)Material_setRef, METH_VARARGS,
- "(f) - Set Material's reflectivity - [0.0, 1.0]"},
- {"setSpec", (PyCFunction)Material_setSpec, METH_VARARGS,
- "(f) - Set Material's specularity - [0.0, 2.0]"},
- {"setSpecTransp", (PyCFunction)Material_setSpecTransp, METH_VARARGS,
- "(f) - Set Material's specular transparency - [0.0, 1.0]"},
- {"setAdd", (PyCFunction)Material_setAdd, METH_VARARGS,
- "(f) - Set Material's glow factor - [0.0, 1.0]"},
- {"setZOffset", (PyCFunction)Material_setZOffset, METH_VARARGS,
- "(f) - Set Material's artificial offset - [0.0, 10.0]"},
- {"setHaloSize", (PyCFunction)Material_setHaloSize, METH_VARARGS,
- "(f) - Set Material's halo size - [0.0, 100.0]"},
- {"setHaloSeed", (PyCFunction)Material_setHaloSeed, METH_VARARGS,
- "(i) - Set Material's halo seed - [0, 255]"},
- {"setFlareSize", (PyCFunction)Material_setFlareSize, METH_VARARGS,
- "(f) - Set Material's factor: (flare size)/(halo size) - [0.1, 25.0]"},
- {"setFlareSeed", (PyCFunction)Material_setFlareSeed, METH_VARARGS,
- "(i) - Set Material's flare seed - [0, 255]"},
- {"setFlareBoost", (PyCFunction)Material_setFlareBoost, METH_VARARGS,
- "(f) - Set Material's flare boost - [0.1, 10.0]"},
- {"setSubSize", (PyCFunction)Material_setSubSize, METH_VARARGS,
- "(f) - Set Material's dimension of subflare,"
- " dots and circles - [0.1, 25.0]"},
- {"setHardness", (PyCFunction)Material_setHardness, METH_VARARGS,
- "(i) - Set Material's hardness - [1, 255 (127 if halo mode is ON)]"},
- {"setNFlares", (PyCFunction)Material_setNFlares, METH_VARARGS,
- "(i) - Set Material's number of flares in halo - [1, 32]"},
- {"setNStars", (PyCFunction)Material_setNStars, METH_VARARGS,
- "(i) - Set Material's number of stars in halo - [3, 50]"},
- {"setNLines", (PyCFunction)Material_setNLines, METH_VARARGS,
- "(i) - Set Material's number of lines in halo - [0, 250]"},
- {"setNRings", (PyCFunction)Material_setNRings, METH_VARARGS,
- "(i) - Set Material's number of rings in halo - [0, 24]"},
- {0}
+ {"getName", (PyCFunction)Material_getName, METH_NOARGS,
+ "() - Return Material Data name"},
+ {"getMode", (PyCFunction)Material_getMode, METH_NOARGS,
+ "() - Return Material mode flags"},
+ {"getRGBCol", (PyCFunction)Material_getRGBCol, METH_NOARGS,
+ "() - Return Material's rgb color triplet"},
+/* {"getAmbCol", (PyCFunction)Material_getAmbCol, METH_NOARGS,
+ "() - Return Material's ambient color"},*/
+ {"getSpecCol", (PyCFunction)Material_getSpecCol, METH_NOARGS,
+ "() - Return Material's specular color"},
+ {"getMirCol", (PyCFunction)Material_getMirCol, METH_NOARGS,
+ "() - Return Material's mirror color"},
+ {"getAmb", (PyCFunction)Material_getAmb, METH_NOARGS,
+ "() - Return Material's ambient color blend factor"},
+ {"getEmit", (PyCFunction)Material_getEmit, METH_NOARGS,
+ "() - Return Material's emitting light intensity"},
+ {"getAlpha", (PyCFunction)Material_getAlpha, METH_NOARGS,
+ "() - Return Material's alpha (transparency) value"},
+ {"getRef", (PyCFunction)Material_getRef, METH_NOARGS,
+ "() - Return Material's reflectivity"},
+ {"getSpec", (PyCFunction)Material_getSpec, METH_NOARGS,
+ "() - Return Material's specularity"},
+ {"getSpecTransp", (PyCFunction)Material_getSpecTransp, METH_NOARGS,
+ "() - Return Material's specular transparency"},
+ {"getAdd", (PyCFunction)Material_getAdd, METH_NOARGS,
+ "() - Return Material's glow factor"},
+ {"getZOffset", (PyCFunction)Material_getZOffset, METH_NOARGS,
+ "() - Return Material's artificial offset for faces"},
+ {"getHaloSize", (PyCFunction)Material_getHaloSize, METH_NOARGS,
+ "() - Return Material's halo size"},
+ {"getHaloSeed", (PyCFunction)Material_getHaloSeed, METH_NOARGS,
+ "() - Return Material's seed for random ring dimension and line "
+ "location in halos"},
+ {"getFlareSize", (PyCFunction)Material_getFlareSize, METH_NOARGS,
+ "() - Return Material's (flare size)/(halo size) factor"},
+ {"getFlareSeed", (PyCFunction)Material_getFlareSeed, METH_NOARGS,
+ "() - Return Material's flare offset in the seed table"},
+ {"getFlareBoost", (PyCFunction)Material_getFlareBoost, METH_NOARGS,
+ "() - Return Material's flare boost"},
+ {"getSubSize", (PyCFunction)Material_getSubSize, METH_NOARGS,
+ "() - Return Material's dimension of subflare, dots and circles"},
+ {"getHardness", (PyCFunction)Material_getHardness, METH_NOARGS,
+ "() - Return Material's specular hardness"},
+ {"getNFlares", (PyCFunction)Material_getNFlares, METH_NOARGS,
+ "() - Return Material's number of flares in halo"},
+ {"getNStars", (PyCFunction)Material_getNStars, METH_NOARGS,
+ "() - Return Material's number of points in the halo stars"},
+ {"getNLines", (PyCFunction)Material_getNLines, METH_NOARGS,
+ "() - Return Material's number of lines in halo"},
+ {"getNRings", (PyCFunction)Material_getNRings, METH_NOARGS,
+ "() - Return Material's number of rings in halo"},
+ {"setName", (PyCFunction)Material_setName, METH_VARARGS,
+ "(s) - Change Material Data name"},
+ {"setMode", (PyCFunction)Material_setMode, METH_VARARGS,
+ "([s[,s]]) - Set Material mode flag(s)"},
+ {"setRGBCol", (PyCFunction)Material_setRGBCol, METH_VARARGS,
+ "(f,f,f or [f,f,f]) - Set Material's rgb color triplet"},
+/* {"setAmbCol", (PyCFunction)Material_setAmbCol, METH_VARARGS,
+ "(f,f,f or [f,f,f]) - Set Material's ambient color"},*/
+ {"setSpecCol", (PyCFunction)Material_setSpecCol, METH_VARARGS,
+ "(f,f,f or [f,f,f]) - Set Material's specular color"},
+ {"setMirCol", (PyCFunction)Material_setMirCol, METH_VARARGS,
+ "(f,f,f or [f,f,f]) - Set Material's mirror color"},
+ {"setAmb", (PyCFunction)Material_setAmb, METH_VARARGS,
+ "(f) - Set how much the Material's color is affected"
+ " by \nthe global ambient colors - [0.0, 1.0]"},
+ {"setEmit", (PyCFunction)Material_setEmit, METH_VARARGS,
+ "(f) - Set Material's emitting light intensity - [0.0, 1.0]"},
+ {"setAlpha", (PyCFunction)Material_setAlpha, METH_VARARGS,
+ "(f) - Set Material's alpha (transparency) - [0.0, 1.0]"},
+ {"setRef", (PyCFunction)Material_setRef, METH_VARARGS,
+ "(f) - Set Material's reflectivity - [0.0, 1.0]"},
+ {"setSpec", (PyCFunction)Material_setSpec, METH_VARARGS,
+ "(f) - Set Material's specularity - [0.0, 2.0]"},
+ {"setSpecTransp", (PyCFunction)Material_setSpecTransp, METH_VARARGS,
+ "(f) - Set Material's specular transparency - [0.0, 1.0]"},
+ {"setAdd", (PyCFunction)Material_setAdd, METH_VARARGS,
+ "(f) - Set Material's glow factor - [0.0, 1.0]"},
+ {"setZOffset", (PyCFunction)Material_setZOffset, METH_VARARGS,
+ "(f) - Set Material's artificial offset - [0.0, 10.0]"},
+ {"setHaloSize", (PyCFunction)Material_setHaloSize, METH_VARARGS,
+ "(f) - Set Material's halo size - [0.0, 100.0]"},
+ {"setHaloSeed", (PyCFunction)Material_setHaloSeed, METH_VARARGS,
+ "(i) - Set Material's halo seed - [0, 255]"},
+ {"setFlareSize", (PyCFunction)Material_setFlareSize, METH_VARARGS,
+ "(f) - Set Material's factor: (flare size)/(halo size) - [0.1, 25.0]"},
+ {"setFlareSeed", (PyCFunction)Material_setFlareSeed, METH_VARARGS,
+ "(i) - Set Material's flare seed - [0, 255]"},
+ {"setFlareBoost", (PyCFunction)Material_setFlareBoost, METH_VARARGS,
+ "(f) - Set Material's flare boost - [0.1, 10.0]"},
+ {"setSubSize", (PyCFunction)Material_setSubSize, METH_VARARGS,
+ "(f) - Set Material's dimension of subflare,"
+ " dots and circles - [0.1, 25.0]"},
+ {"setHardness", (PyCFunction)Material_setHardness, METH_VARARGS,
+ "(i) - Set Material's hardness - [1, 255 (127 if halo mode is ON)]"},
+ {"setNFlares", (PyCFunction)Material_setNFlares, METH_VARARGS,
+ "(i) - Set Material's number of flares in halo - [1, 32]"},
+ {"setNStars", (PyCFunction)Material_setNStars, METH_VARARGS,
+ "(i) - Set Material's number of stars in halo - [3, 50]"},
+ {"setNLines", (PyCFunction)Material_setNLines, METH_VARARGS,
+ "(i) - Set Material's number of lines in halo - [0, 250]"},
+ {"setNRings", (PyCFunction)Material_setNRings, METH_VARARGS,
+ "(i) - Set Material's number of rings in halo - [0, 24]"},
+ {0}
};
/*****************************************************************************/
-/* Python Material_Type callback function prototypes: */
+/* Python Material_Type callback function prototypes: */
/*****************************************************************************/
static void Material_dealloc (BPy_Material *self);
static int Material_setAttr (BPy_Material *self, char *name, PyObject *v);
@@ -490,116 +492,116 @@ static PyObject *Material_getAttr (BPy_Material *self, char *name);
static PyObject *Material_repr (BPy_Material *self);
/*****************************************************************************/
-/* Python Material_Type structure definition: */
+/* Python Material_Type structure definition: */
/*****************************************************************************/
PyTypeObject Material_Type =
{
- PyObject_HEAD_INIT(NULL)
- 0, /* ob_size */
- "Blender Material", /* tp_name */
- sizeof (BPy_Material), /* tp_basicsize */
- 0, /* tp_itemsize */
- /* methods */
- (destructor)Material_dealloc, /* tp_dealloc */
- 0, /* tp_print */
- (getattrfunc)Material_getAttr, /* tp_getattr */
- (setattrfunc)Material_setAttr, /* tp_setattr */
- 0, /* tp_compare */
- (reprfunc)Material_repr, /* tp_repr */
- 0, /* tp_as_number */
- 0, /* tp_as_sequence */
- 0, /* tp_as_mapping */
- 0, /* tp_as_hash */
- 0,0,0,0,0,0,
- 0, /* tp_doc */
- 0,0,0,0,0,0,
- BPy_Material_methods, /* tp_methods */
- 0, /* tp_members */
+ PyObject_HEAD_INIT(NULL)
+ 0, /* ob_size */
+ "Blender Material", /* tp_name */
+ sizeof (BPy_Material), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ /* methods */
+ (destructor)Material_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ (getattrfunc)Material_getAttr, /* tp_getattr */
+ (setattrfunc)Material_setAttr, /* tp_setattr */
+ 0, /* tp_compare */
+ (reprfunc)Material_repr, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_as_hash */
+ 0,0,0,0,0,0,
+ 0, /* tp_doc */
+ 0,0,0,0,0,0,
+ BPy_Material_methods, /* tp_methods */
+ 0, /* tp_members */
};
/*****************************************************************************/
-/* Function: Material_dealloc */
+/* Function: Material_dealloc */
/* Description: This is a callback function for the BPy_Material type. It is */
-/* the destructor function. */
+/* the destructor function. */
/*****************************************************************************/
static void Material_dealloc (BPy_Material *self)
{
- Py_DECREF (self->col);
- Py_DECREF (self->amb);
- Py_DECREF (self->spec);
- Py_DECREF (self->mir);
- PyObject_DEL (self);
+ Py_DECREF (self->col);
+ Py_DECREF (self->amb);
+ Py_DECREF (self->spec);
+ Py_DECREF (self->mir);
+ PyObject_DEL (self);
}
/*****************************************************************************/
-/* Function: Material_CreatePyObject */
+/* Function: Material_CreatePyObject */
/* Description: This function will create a new BPy_Material from an existing*/
-/* Blender material structure. */
+/* Blender material structure. */
/*****************************************************************************/
PyObject *Material_CreatePyObject (struct Material *mat)
{
- BPy_Material *pymat;
- float *col[3], *amb[3], *spec[3], *mir[3];
+ BPy_Material *pymat;
+ float *col[3], *amb[3], *spec[3], *mir[3];
- pymat = (BPy_Material *)PyObject_NEW (BPy_Material, &Material_Type);
+ pymat = (BPy_Material *)PyObject_NEW (BPy_Material, &Material_Type);
- if (!pymat)
- return EXPP_ReturnPyObjError (PyExc_MemoryError,
- "couldn't create BPy_Material object");
+ if (!pymat)
+ return EXPP_ReturnPyObjError (PyExc_MemoryError,
+ "couldn't create BPy_Material object");
- pymat->material = mat;
+ pymat->material = mat;
- col[0] = &mat->r;
- col[1] = &mat->g;
- col[2] = &mat->b;
+ col[0] = &mat->r;
+ col[1] = &mat->g;
+ col[2] = &mat->b;
- amb[0] = &mat->ambr;
- amb[1] = &mat->ambg;
- amb[2] = &mat->ambb;
+ amb[0] = &mat->ambr;
+ amb[1] = &mat->ambg;
+ amb[2] = &mat->ambb;
- spec[0] = &mat->specr;
- spec[1] = &mat->specg;
- spec[2] = &mat->specb;
+ spec[0] = &mat->specr;
+ spec[1] = &mat->specg;
+ spec[2] = &mat->specb;
- mir[0] = &mat->mirr;
- mir[1] = &mat->mirg;
- mir[2] = &mat->mirb;
+ mir[0] = &mat->mirr;
+ mir[1] = &mat->mirg;
+ mir[2] = &mat->mirb;
- pymat->col = (BPy_rgbTuple *)rgbTuple_New(col);
- pymat->amb = (BPy_rgbTuple *)rgbTuple_New(amb);
- pymat->spec = (BPy_rgbTuple *)rgbTuple_New(spec);
- pymat->mir = (BPy_rgbTuple *)rgbTuple_New(mir);
+ pymat->col = (BPy_rgbTuple *)rgbTuple_New(col);
+ pymat->amb = (BPy_rgbTuple *)rgbTuple_New(amb);
+ pymat->spec = (BPy_rgbTuple *)rgbTuple_New(spec);
+ pymat->mir = (BPy_rgbTuple *)rgbTuple_New(mir);
- return (PyObject *)pymat;
+ return (PyObject *)pymat;
}
/*****************************************************************************/
-/* Function: Material_CheckPyObject */
+/* Function: Material_CheckPyObject */
/* Description: This function returns true when the given PyObject is of the */
-/* type Material. Otherwise it will return false. */
+/* type Material. Otherwise it will return false. */
/*****************************************************************************/
int Material_CheckPyObject (PyObject *pyobj)
{
- return (pyobj->ob_type == &Material_Type);
+ return (pyobj->ob_type == &Material_Type);
}
/*****************************************************************************/
-/* Function: Material_FromPyObject */
-/* Description: This function returns the Blender material from the given */
-/* PyObject. */
+/* Function: Material_FromPyObject */
+/* Description: This function returns the Blender material from the given */
+/* PyObject. */
/*****************************************************************************/
Material *Material_FromPyObject (PyObject *pyobj)
{
- return ((BPy_Material *)pyobj)->material;
+ return ((BPy_Material *)pyobj)->material;
}
/*****************************************************************************/
-/* Description: Returns the object with the name specified by the argument */
-/* name. Note that the calling function has to remove the first */
-/* two characters of the object name. These two characters */
-/* specify the type of the object (OB, ME, WO, ...) */
-/* The function will return NULL when no object with the given */
-/* name is found. */
+/* Description: Returns the object with the name specified by the argument */
+/* name. Note that the calling function has to remove the first */
+/* two characters of the object name. These two characters */
+/* specify the type of the object (OB, ME, WO, ...) */
+/* The function will return NULL when no object with the given */
+/* name is found. */
/*****************************************************************************/
Material * GetMaterialByName (char * name)
{
@@ -620,253 +622,253 @@ Material * GetMaterialByName (char * name)
}
/*****************************************************************************/
-/* Python BPy_Material methods: */
+/* Python BPy_Material methods: */
/*****************************************************************************/
static PyObject *Material_getName(BPy_Material *self)
{
- PyObject *attr = PyString_FromString(self->material->id.name+2);
+ PyObject *attr = PyString_FromString(self->material->id.name+2);
- if (attr) return attr;
+ if (attr) return attr;
- return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.name attribute"));
+ return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.name attribute"));
}
static PyObject *Material_getMode(BPy_Material *self)
{
- PyObject *attr = PyInt_FromLong((long)self->material->mode);
+ PyObject *attr = PyInt_FromLong((long)self->material->mode);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.Mode attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.Mode attribute");
}
static PyObject *Material_getRGBCol(BPy_Material *self)
{
- return rgbTuple_getCol(self->col);
+ return rgbTuple_getCol(self->col);
}
/*
static PyObject *Material_getAmbCol(BPy_Material *self)
{
- return rgbTuple_getCol(self->amb);
+ return rgbTuple_getCol(self->amb);
}
*/
static PyObject *Material_getSpecCol(BPy_Material *self)
{
- return rgbTuple_getCol(self->spec);
+ return rgbTuple_getCol(self->spec);
}
static PyObject *Material_getMirCol(BPy_Material *self)
{
- return rgbTuple_getCol(self->mir);
+ return rgbTuple_getCol(self->mir);
}
static PyObject *Material_getAmb(BPy_Material *self)
{
- PyObject *attr = PyFloat_FromDouble((double)self->material->amb);
+ PyObject *attr = PyFloat_FromDouble((double)self->material->amb);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.amb attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.amb attribute");
}
static PyObject *Material_getEmit(BPy_Material *self)
{
- PyObject *attr = PyFloat_FromDouble((double)self->material->emit);
+ PyObject *attr = PyFloat_FromDouble((double)self->material->emit);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.emit attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.emit attribute");
}
static PyObject *Material_getAlpha(BPy_Material *self)
{
- PyObject *attr = PyFloat_FromDouble((double)self->material->alpha);
+ PyObject *attr = PyFloat_FromDouble((double)self->material->alpha);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.alpha attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.alpha attribute");
}
static PyObject *Material_getRef(BPy_Material *self)
{
- PyObject *attr = PyFloat_FromDouble((double)self->material->ref);
+ PyObject *attr = PyFloat_FromDouble((double)self->material->ref);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.ref attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.ref attribute");
}
static PyObject *Material_getSpec(BPy_Material *self)
{
- PyObject *attr = PyFloat_FromDouble((double)self->material->spec);
+ PyObject *attr = PyFloat_FromDouble((double)self->material->spec);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.spec attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.spec attribute");
}
static PyObject *Material_getSpecTransp(BPy_Material *self)
{
- PyObject *attr = PyFloat_FromDouble((double)self->material->spectra);
+ PyObject *attr = PyFloat_FromDouble((double)self->material->spectra);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.specTransp attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.specTransp attribute");
}
static PyObject *Material_getAdd(BPy_Material *self)
{
- PyObject *attr = PyFloat_FromDouble((double)self->material->add);
+ PyObject *attr = PyFloat_FromDouble((double)self->material->add);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.add attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.add attribute");
}
static PyObject *Material_getZOffset(BPy_Material *self)
{
- PyObject *attr = PyFloat_FromDouble((double)self->material->zoffs);
+ PyObject *attr = PyFloat_FromDouble((double)self->material->zoffs);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.zOffset attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.zOffset attribute");
}
static PyObject *Material_getHaloSize(BPy_Material *self)
{
- PyObject *attr = PyFloat_FromDouble((double)self->material->hasize);
+ PyObject *attr = PyFloat_FromDouble((double)self->material->hasize);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.haloSize attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.haloSize attribute");
}
static PyObject *Material_getFlareSize(BPy_Material *self)
{
- PyObject *attr = PyFloat_FromDouble((double)self->material->flaresize);
+ PyObject *attr = PyFloat_FromDouble((double)self->material->flaresize);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.flareSize attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.flareSize attribute");
}
static PyObject *Material_getFlareBoost(BPy_Material *self)
{
- PyObject *attr = PyFloat_FromDouble((double)self->material->flareboost);
+ PyObject *attr = PyFloat_FromDouble((double)self->material->flareboost);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.flareBoost attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.flareBoost attribute");
}
static PyObject *Material_getSubSize(BPy_Material *self)
{
- PyObject *attr = PyFloat_FromDouble((double)self->material->subsize);
+ PyObject *attr = PyFloat_FromDouble((double)self->material->subsize);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.subSize attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.subSize attribute");
}
static PyObject *Material_getHaloSeed(BPy_Material *self)
{
- PyObject *attr = PyInt_FromLong((long)self->material->seed1);
+ PyObject *attr = PyInt_FromLong((long)self->material->seed1);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.haloSeed attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.haloSeed attribute");
}
static PyObject *Material_getFlareSeed(BPy_Material *self)
{
- PyObject *attr = PyInt_FromLong((long)self->material->seed2);
+ PyObject *attr = PyInt_FromLong((long)self->material->seed2);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.flareSeed attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.flareSeed attribute");
}
static PyObject *Material_getHardness(BPy_Material *self)
{
- PyObject *attr = PyInt_FromLong((long)self->material->har);
+ PyObject *attr = PyInt_FromLong((long)self->material->har);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.hard attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.hard attribute");
}
static PyObject *Material_getNFlares(BPy_Material *self)
{
- PyObject *attr = PyInt_FromLong((long)self->material->flarec);
+ PyObject *attr = PyInt_FromLong((long)self->material->flarec);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.nFlares attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.nFlares attribute");
}
static PyObject *Material_getNStars(BPy_Material *self)
{
- PyObject *attr = PyInt_FromLong((long)self->material->starc);
+ PyObject *attr = PyInt_FromLong((long)self->material->starc);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.nStars attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.nStars attribute");
}
static PyObject *Material_getNLines(BPy_Material *self)
{
- PyObject *attr = PyInt_FromLong((long)self->material->linec);
+ PyObject *attr = PyInt_FromLong((long)self->material->linec);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.nLines attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.nLines attribute");
}
static PyObject *Material_getNRings(BPy_Material *self)
{
- PyObject *attr = PyInt_FromLong((long)self->material->ringc);
+ PyObject *attr = PyInt_FromLong((long)self->material->ringc);
- if (attr) return attr;
+ if (attr) return attr;
- return EXPP_ReturnPyObjError (PyExc_RuntimeError,
- "couldn't get Material.nRings attribute");
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get Material.nRings attribute");
}
static PyObject *Material_setName(BPy_Material *self, PyObject *args)
{
- char *name;
- char buf[21];
+ char *name;
+ char buf[21];
- if (!PyArg_ParseTuple(args, "s", &name))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected string argument"));
+ if (!PyArg_ParseTuple(args, "s", &name))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected string argument"));
- PyOS_snprintf(buf, sizeof(buf), "%s", name);
+ PyOS_snprintf(buf, sizeof(buf), "%s", name);
- rename_id(&self->material->id, buf);
+ rename_id(&self->material->id, buf);
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
/* Possible modes are traceable, shadow, shadeless, wire, vcolLight,
@@ -875,710 +877,712 @@ static PyObject *Material_setName(BPy_Material *self, PyObject *args)
* haloShaded, haloFlare */
static PyObject *Material_setMode(BPy_Material *self, PyObject *args)
{
- int i, flag = 0;
- char *m[21] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL,
- NULL, NULL, NULL, NULL, NULL, NULL, NULL,
- NULL, NULL, NULL, NULL, NULL, NULL, NULL};
-
- if (!PyArg_ParseTuple(args, "|sssssssssssssssssssss",
- &m[0], &m[1], &m[2], &m[3], &m[4], &m[5], &m[6],
- &m[7], &m[8], &m[9], &m[10], &m[11], &m[12], &m[13],
- &m[14], &m[15], &m[16], &m[17], &m[18], &m[19], &m[20]))
- {
- return (EXPP_ReturnPyObjError (PyExc_AttributeError,
- "expected from none to 21 string argument(s)"));
- }
-
- for (i = 0; i < 21; i++) {
- if (m[i] == NULL) break;
- if (strcmp(m[i], "Traceable") == 0)
- flag |= (short)EXPP_MAT_MODE_TRACEABLE;
- else if (strcmp(m[i], "Shadow") == 0)
- flag |= (short)EXPP_MAT_MODE_SHADOW;
- else if (strcmp(m[i], "Shadeless") == 0)
- flag |= (short)EXPP_MAT_MODE_SHADELESS;
- else if (strcmp(m[i], "Wire") == 0)
- flag |= (short)EXPP_MAT_MODE_WIRE;
- else if (strcmp(m[i], "VColLight") == 0)
- flag |= (short)EXPP_MAT_MODE_VCOL_LIGHT;
- else if (strcmp(m[i], "VColPaint") == 0)
- flag |= (short)EXPP_MAT_MODE_VCOL_PAINT;
- else if (strcmp(m[i], "Halo") == 0)
- flag |= (short)EXPP_MAT_MODE_HALO;
- else if (strcmp(m[i], "ZTransp") == 0)
- flag |= (short)EXPP_MAT_MODE_ZTRANSP;
- else if (strcmp(m[i], "ZInvert") == 0)
- flag |= (short)EXPP_MAT_MODE_ZINVERT;
- else if (strcmp(m[i], "HaloRings") == 0)
- flag |= (short)EXPP_MAT_MODE_HALORINGS;
- else if (strcmp(m[i], "Env") == 0)
- flag |= (short)EXPP_MAT_MODE_ENV;
- else if (strcmp(m[i], "HaloLines") == 0)
- flag |= (short)EXPP_MAT_MODE_HALOLINES;
- else if (strcmp(m[i], "OnlyShadow") == 0)
- flag |= (short)EXPP_MAT_MODE_ONLYSHADOW;
- else if (strcmp(m[i], "HaloXAlpha") == 0)
- flag |= (short)EXPP_MAT_MODE_HALOXALPHA;
- else if (strcmp(m[i], "HaloStar") == 0)
- flag |= (short)EXPP_MAT_MODE_HALOSTAR;
- else if (strcmp(m[i], "TexFace") == 0)
- flag |= (short)EXPP_MAT_MODE_TEXFACE;
- else if (strcmp(m[i], "HaloTex") == 0)
- flag |= (short)EXPP_MAT_MODE_HALOTEX;
- else if (strcmp(m[i], "HaloPuno") == 0)
- flag |= (short)EXPP_MAT_MODE_HALOPUNO;
- else if (strcmp(m[i], "NoMist") == 0)
- flag |= (short)EXPP_MAT_MODE_NOMIST;
- else if (strcmp(m[i], "HaloShaded") == 0)
- flag |= (short)EXPP_MAT_MODE_HALOSHADE;
- else if (strcmp(m[i], "HaloFlare") == 0)
- flag |= (short)EXPP_MAT_MODE_HALOFLARE;
- else
- return (EXPP_ReturnPyObjError (PyExc_AttributeError,
- "unknown Material mode argument"));
- }
-
- self->material->mode = flag;
-
- Py_INCREF(Py_None);
- return Py_None;
+ int i, flag = 0;
+ char *m[22] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
+
+ if (!PyArg_ParseTuple(args, "|ssssssssssssssssssssss",
+ &m[0], &m[1], &m[2], &m[3], &m[4], &m[5], &m[6],
+ &m[7], &m[8], &m[9], &m[10], &m[11], &m[12], &m[13],
+ &m[14], &m[15], &m[16], &m[17], &m[18], &m[19], &m[20], &m[21]))
+ {
+ return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+ "expected from none to 22 string argument(s)"));
+ }
+
+ for (i = 0; i < 22; i++) {
+ if (m[i] == NULL) break;
+ if (strcmp(m[i], "Traceable") == 0)
+ flag |= EXPP_MAT_MODE_TRACEABLE;
+ else if (strcmp(m[i], "Shadow") == 0)
+ flag |= EXPP_MAT_MODE_SHADOW;
+ else if (strcmp(m[i], "Shadeless") == 0)
+ flag |= EXPP_MAT_MODE_SHADELESS;
+ else if (strcmp(m[i], "Wire") == 0)
+ flag |= EXPP_MAT_MODE_WIRE;
+ else if (strcmp(m[i], "VColLight") == 0)
+ flag |= EXPP_MAT_MODE_VCOL_LIGHT;
+ else if (strcmp(m[i], "VColPaint") == 0)
+ flag |= EXPP_MAT_MODE_VCOL_PAINT;
+ else if (strcmp(m[i], "Halo") == 0)
+ flag |= EXPP_MAT_MODE_HALO;
+ else if (strcmp(m[i], "ZTransp") == 0)
+ flag |= EXPP_MAT_MODE_ZTRANSP;
+ else if (strcmp(m[i], "ZInvert") == 0)
+ flag |= EXPP_MAT_MODE_ZINVERT;
+ else if (strcmp(m[i], "HaloRings") == 0)
+ flag |= EXPP_MAT_MODE_HALORINGS;
+ else if (strcmp(m[i], "Env") == 0)
+ flag |= EXPP_MAT_MODE_ENV;
+ else if (strcmp(m[i], "HaloLines") == 0)
+ flag |= EXPP_MAT_MODE_HALOLINES;
+ else if (strcmp(m[i], "OnlyShadow") == 0)
+ flag |= EXPP_MAT_MODE_ONLYSHADOW;
+ else if (strcmp(m[i], "HaloXAlpha") == 0)
+ flag |= EXPP_MAT_MODE_HALOXALPHA;
+ else if (strcmp(m[i], "HaloStar") == 0)
+ flag |= EXPP_MAT_MODE_HALOSTAR;
+ else if (strcmp(m[i], "TexFace") == 0)
+ flag |= EXPP_MAT_MODE_TEXFACE;
+ else if (strcmp(m[i], "HaloTex") == 0)
+ flag |= EXPP_MAT_MODE_HALOTEX;
+ else if (strcmp(m[i], "HaloPuno") == 0)
+ flag |= EXPP_MAT_MODE_HALOPUNO;
+ else if (strcmp(m[i], "NoMist") == 0)
+ flag |= EXPP_MAT_MODE_NOMIST;
+ else if (strcmp(m[i], "HaloShaded") == 0)
+ flag |= EXPP_MAT_MODE_HALOSHADE;
+ else if (strcmp(m[i], "HaloFlare") == 0)
+ flag |= EXPP_MAT_MODE_HALOFLARE;
+ else if (strcmp(m[i], "Radio") == 0)
+ flag |= EXPP_MAT_MODE_RADIO;
+ else
+ return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+ "unknown Material mode argument"));
+ }
+
+ self->material->mode = flag;
+
+ Py_INCREF(Py_None);
+ return Py_None;
}
/* Another helper function, for the same reason.
* (See comment before Material_setIntType above). */
static PyObject *Material_setIntMode(BPy_Material *self, PyObject *args)
{
- int value;
+ int value;
- if (!PyArg_ParseTuple(args, "i", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected int argument"));
+ if (!PyArg_ParseTuple(args, "i", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected int argument"));
- self->material->mode = value;
+ self->material->mode = value;
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *Material_setRGBCol (BPy_Material *self, PyObject *args)
{
- return rgbTuple_setCol(self->col, args);
+ return rgbTuple_setCol(self->col, args);
}
/*
static PyObject *Material_setAmbCol (BPy_Material *self, PyObject *args)
{
- return rgbTuple_setCol(self->amb, args);
+ return rgbTuple_setCol(self->amb, args);
}
*/
static PyObject *Material_setSpecCol (BPy_Material *self, PyObject *args)
{
- return rgbTuple_setCol(self->spec, args);
+ return rgbTuple_setCol(self->spec, args);
}
static PyObject *Material_setMirCol (BPy_Material *self, PyObject *args)
{
- return rgbTuple_setCol(self->mir, args);
+ return rgbTuple_setCol(self->mir, args);
}
static PyObject *Material_setColorComponent(BPy_Material *self, char *key,
- PyObject *args)
+ PyObject *args)
{ /* for compatibility with old bpython */
- float value;
+ float value;
- if (!PyArg_ParseTuple(args, "f", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected float argument in [0.0, 1.0]"));
+ if (!PyArg_ParseTuple(args, "f", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected float argument in [0.0, 1.0]"));
- value = EXPP_ClampFloat (value, EXPP_MAT_COL_MIN,
- EXPP_MAT_COL_MAX);
+ value = EXPP_ClampFloat (value, EXPP_MAT_COL_MIN,
+ EXPP_MAT_COL_MAX);
- if (!strcmp(key, "R"))
- self->material->r = value;
- else if (!strcmp(key, "G"))
- self->material->g = value;
- else if (!strcmp(key, "B"))
- self->material->b = value;
- else if (!strcmp(key, "specR"))
- self->material->specr = value;
- else if (!strcmp(key, "specG"))
- self->material->specg = value;
- else if (!strcmp(key, "specB"))
- self->material->specb = value;
+ if (!strcmp(key, "R"))
+ self->material->r = value;
+ else if (!strcmp(key, "G"))
+ self->material->g = value;
+ else if (!strcmp(key, "B"))
+ self->material->b = value;
+ else if (!strcmp(key, "specR"))
+ self->material->specr = value;
+ else if (!strcmp(key, "specG"))
+ self->material->specg = value;
+ else if (!strcmp(key, "specB"))
+ self->material->specb = value;
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setAmb(BPy_Material *self, PyObject *args)
{
- float value;
+ float value;
- if (!PyArg_ParseTuple(args, "f", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected float argument in [0.0, 1.0]"));
+ if (!PyArg_ParseTuple(args, "f", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected float argument in [0.0, 1.0]"));
- self->material->amb = EXPP_ClampFloat (value, EXPP_MAT_AMB_MIN,
- EXPP_MAT_AMB_MAX);
+ self->material->amb = EXPP_ClampFloat (value, EXPP_MAT_AMB_MIN,
+ EXPP_MAT_AMB_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setEmit(BPy_Material *self, PyObject *args)
{
- float value;
+ float value;
- if (!PyArg_ParseTuple(args, "f", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected float argument in [0.0, 1.0]"));
+ if (!PyArg_ParseTuple(args, "f", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected float argument in [0.0, 1.0]"));
- self->material->emit = EXPP_ClampFloat (value, EXPP_MAT_EMIT_MIN,
- EXPP_MAT_EMIT_MAX);
+ self->material->emit = EXPP_ClampFloat (value, EXPP_MAT_EMIT_MIN,
+ EXPP_MAT_EMIT_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setSpecTransp(BPy_Material *self, PyObject *args)
{
- float value;
+ float value;
- if (!PyArg_ParseTuple(args, "f", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected float argument in [0.0, 1.0]"));
+ if (!PyArg_ParseTuple(args, "f", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected float argument in [0.0, 1.0]"));
- self->material->spectra = EXPP_ClampFloat (value, EXPP_MAT_SPECTRA_MIN,
- EXPP_MAT_SPECTRA_MAX);
+ self->material->spectra = EXPP_ClampFloat (value, EXPP_MAT_SPECTRA_MIN,
+ EXPP_MAT_SPECTRA_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setAlpha(BPy_Material *self, PyObject *args)
{
- float value;
+ float value;
- if (!PyArg_ParseTuple(args, "f", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected float argument in [0.0, 1.0]"));
+ if (!PyArg_ParseTuple(args, "f", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected float argument in [0.0, 1.0]"));
- self->material->alpha = EXPP_ClampFloat (value, EXPP_MAT_ALPHA_MIN,
- EXPP_MAT_ALPHA_MAX);
+ self->material->alpha = EXPP_ClampFloat (value, EXPP_MAT_ALPHA_MIN,
+ EXPP_MAT_ALPHA_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setRef(BPy_Material *self, PyObject *args)
{
- float value;
+ float value;
- if (!PyArg_ParseTuple(args, "f", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected float argument in [0.0, 1.0]"));
+ if (!PyArg_ParseTuple(args, "f", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected float argument in [0.0, 1.0]"));
- self->material->ref = EXPP_ClampFloat (value, EXPP_MAT_REF_MIN,
- EXPP_MAT_REF_MAX);
+ self->material->ref = EXPP_ClampFloat (value, EXPP_MAT_REF_MIN,
+ EXPP_MAT_REF_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setSpec(BPy_Material *self, PyObject *args)
{
- float value;
+ float value;
- if (!PyArg_ParseTuple(args, "f", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected float argument in [0.0, 1.0]"));
+ if (!PyArg_ParseTuple(args, "f", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected float argument in [0.0, 1.0]"));
- self->material->spec = EXPP_ClampFloat (value, EXPP_MAT_SPEC_MIN,
- EXPP_MAT_SPEC_MAX);
+ self->material->spec = EXPP_ClampFloat (value, EXPP_MAT_SPEC_MIN,
+ EXPP_MAT_SPEC_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setZOffset(BPy_Material *self, PyObject *args)
{
- float value;
+ float value;
- if (!PyArg_ParseTuple(args, "f", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected float argument in [0.0, 10.0]"));
+ if (!PyArg_ParseTuple(args, "f", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected float argument in [0.0, 10.0]"));
- self->material->zoffs = EXPP_ClampFloat (value, EXPP_MAT_ZOFFS_MIN,
- EXPP_MAT_ZOFFS_MAX);
+ self->material->zoffs = EXPP_ClampFloat (value, EXPP_MAT_ZOFFS_MIN,
+ EXPP_MAT_ZOFFS_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setAdd(BPy_Material *self, PyObject *args)
{
- float value;
+ float value;
- if (!PyArg_ParseTuple(args, "f", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected float argument in [0.0, 1.0]"));
+ if (!PyArg_ParseTuple(args, "f", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected float argument in [0.0, 1.0]"));
- self->material->add = EXPP_ClampFloat (value, EXPP_MAT_ADD_MIN,
- EXPP_MAT_ADD_MAX);
+ self->material->add = EXPP_ClampFloat (value, EXPP_MAT_ADD_MIN,
+ EXPP_MAT_ADD_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setHaloSize(BPy_Material *self, PyObject *args)
{
- float value;
+ float value;
- if (!PyArg_ParseTuple(args, "f", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected float argument in [0.0, 100.0]"));
+ if (!PyArg_ParseTuple(args, "f", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected float argument in [0.0, 100.0]"));
- self->material->hasize = EXPP_ClampFloat (value, EXPP_MAT_HALOSIZE_MIN,
- EXPP_MAT_HALOSIZE_MAX);
+ self->material->hasize = EXPP_ClampFloat (value, EXPP_MAT_HALOSIZE_MIN,
+ EXPP_MAT_HALOSIZE_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setFlareSize(BPy_Material *self, PyObject *args)
{
- float value;
+ float value;
- if (!PyArg_ParseTuple(args, "f", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected float argument in [0.1, 25.0]"));
+ if (!PyArg_ParseTuple(args, "f", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected float argument in [0.1, 25.0]"));
- self->material->flaresize = EXPP_ClampFloat (value, EXPP_MAT_FLARESIZE_MIN,
- EXPP_MAT_FLARESIZE_MAX);
+ self->material->flaresize = EXPP_ClampFloat (value, EXPP_MAT_FLARESIZE_MIN,
+ EXPP_MAT_FLARESIZE_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setFlareBoost(BPy_Material *self, PyObject *args)
{
- float value;
+ float value;
- if (!PyArg_ParseTuple(args, "f", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected float argument in [0.1, 10.0]"));
+ if (!PyArg_ParseTuple(args, "f", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected float argument in [0.1, 10.0]"));
- self->material->flareboost = EXPP_ClampFloat(value, EXPP_MAT_FLAREBOOST_MIN,
- EXPP_MAT_FLAREBOOST_MAX);
+ self->material->flareboost = EXPP_ClampFloat(value, EXPP_MAT_FLAREBOOST_MIN,
+ EXPP_MAT_FLAREBOOST_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setSubSize(BPy_Material *self, PyObject *args)
{
- float value;
+ float value;
- if (!PyArg_ParseTuple(args, "f", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected float argument in [0.1, 25.0]"));
+ if (!PyArg_ParseTuple(args, "f", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected float argument in [0.1, 25.0]"));
- self->material->subsize = EXPP_ClampFloat (value, EXPP_MAT_SUBSIZE_MIN,
- EXPP_MAT_SUBSIZE_MAX);
+ self->material->subsize = EXPP_ClampFloat (value, EXPP_MAT_SUBSIZE_MIN,
+ EXPP_MAT_SUBSIZE_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setHaloSeed(BPy_Material *self, PyObject *args)
{
- short value;
+ short value;
- if (!PyArg_ParseTuple(args, "h", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected int argument in [1, 255]"));
+ if (!PyArg_ParseTuple(args, "h", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected int argument in [1, 255]"));
- self->material->seed1 = EXPP_ClampInt (value, EXPP_MAT_HALOSEED_MIN,
- EXPP_MAT_HALOSEED_MAX);
+ self->material->seed1 = EXPP_ClampInt (value, EXPP_MAT_HALOSEED_MIN,
+ EXPP_MAT_HALOSEED_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setFlareSeed(BPy_Material *self, PyObject *args)
{
- short value;
+ short value;
- if (!PyArg_ParseTuple(args, "h", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected int argument in [1, 255]"));
+ if (!PyArg_ParseTuple(args, "h", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected int argument in [1, 255]"));
- self->material->seed2 = EXPP_ClampInt (value, EXPP_MAT_FLARESEED_MIN,
- EXPP_MAT_FLARESEED_MAX);
+ self->material->seed2 = EXPP_ClampInt (value, EXPP_MAT_FLARESEED_MIN,
+ EXPP_MAT_FLARESEED_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setHardness(BPy_Material *self, PyObject *args)
{
- short value;
+ short value;
- if (!PyArg_ParseTuple(args, "h", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected int argument in [1, 255]"));
+ if (!PyArg_ParseTuple(args, "h", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected int argument in [1, 255]"));
- self->material->har = EXPP_ClampInt (value, EXPP_MAT_HARD_MIN,
- EXPP_MAT_HARD_MAX);
+ self->material->har = EXPP_ClampInt (value, EXPP_MAT_HARD_MIN,
+ EXPP_MAT_HARD_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setNFlares(BPy_Material *self, PyObject *args)
{
- short value;
+ short value;
- if (!PyArg_ParseTuple(args, "h", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected int argument in [1, 32]"));
+ if (!PyArg_ParseTuple(args, "h", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected int argument in [1, 32]"));
- self->material->flarec = EXPP_ClampInt (value, EXPP_MAT_NFLARES_MIN,
- EXPP_MAT_NFLARES_MAX);
+ self->material->flarec = EXPP_ClampInt (value, EXPP_MAT_NFLARES_MIN,
+ EXPP_MAT_NFLARES_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setNStars(BPy_Material *self, PyObject *args)
{
- short value;
+ short value;
- if (!PyArg_ParseTuple(args, "h", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected int argument in [3, 50]"));
+ if (!PyArg_ParseTuple(args, "h", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected int argument in [3, 50]"));
- self->material->starc = EXPP_ClampInt (value, EXPP_MAT_NSTARS_MIN,
- EXPP_MAT_NSTARS_MAX);
+ self->material->starc = EXPP_ClampInt (value, EXPP_MAT_NSTARS_MIN,
+ EXPP_MAT_NSTARS_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setNLines(BPy_Material *self, PyObject *args)
{
- short value;
+ short value;
- if (!PyArg_ParseTuple(args, "h", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected int argument in [0, 250]"));
+ if (!PyArg_ParseTuple(args, "h", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected int argument in [0, 250]"));
- self->material->linec = EXPP_ClampInt (value, EXPP_MAT_NLINES_MIN,
- EXPP_MAT_NLINES_MAX);
+ self->material->linec = EXPP_ClampInt (value, EXPP_MAT_NLINES_MIN,
+ EXPP_MAT_NLINES_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
static PyObject *Material_setNRings(BPy_Material *self, PyObject *args)
{
- short value;
+ short value;
- if (!PyArg_ParseTuple(args, "h", &value))
- return (EXPP_ReturnPyObjError (PyExc_TypeError,
- "expected int argument in [0, 24]"));
+ if (!PyArg_ParseTuple(args, "h", &value))
+ return (EXPP_ReturnPyObjError (PyExc_TypeError,
+ "expected int argument in [0, 24]"));
- self->material->ringc = EXPP_ClampInt (value, EXPP_MAT_NRINGS_MIN,
- EXPP_MAT_NRINGS_MAX);
+ self->material->ringc = EXPP_ClampInt (value, EXPP_MAT_NRINGS_MIN,
+ EXPP_MAT_NRINGS_MAX);
- return EXPP_incr_ret (Py_None);
+ return EXPP_incr_ret (Py_None);
}
/*****************************************************************************/
-/* Function: Material_getAttr */
+/* Function: Material_getAttr */
/* Description: This is a callback function for the BPy_Material type. It is */
-/* the function that accesses BPy_Material "member variables" */
-/* and methods. */
+/* the function that accesses BPy_Material "member variables" */
+/* and methods. */
/*****************************************************************************/
static PyObject *Material_getAttr (BPy_Material *self, char *name)
{
- PyObject *attr = Py_None;
-
- if (strcmp(name, "name") == 0)
- attr = PyString_FromString(self->material->id.name+2);
- else if (strcmp(name, "mode") == 0)
- attr = PyInt_FromLong(self->material->mode);
- else if (strcmp(name, "rgbCol") == 0)
- attr = Material_getRGBCol(self);
-/* else if (strcmp(name, "ambCol") == 0)
- attr = Material_getAmbCol(self);*/
- else if (strcmp(name, "specCol") == 0)
- attr = Material_getSpecCol(self);
- else if (strcmp(name, "mirCol") == 0)
- attr = Material_getMirCol(self);
- else if (strcmp(name, "R") == 0)
- attr = PyFloat_FromDouble((double)self->material->r);
- else if (strcmp(name, "G") == 0)
- attr = PyFloat_FromDouble((double)self->material->g);
- else if (strcmp(name, "B") == 0)
- attr = PyFloat_FromDouble((double)self->material->b);
- else if (strcmp(name, "specR") == 0)
- attr = PyFloat_FromDouble((double)self->material->specr);
- else if (strcmp(name, "specG") == 0)
- attr = PyFloat_FromDouble((double)self->material->specg);
- else if (strcmp(name, "specB") == 0)
- attr = PyFloat_FromDouble((double)self->material->specb);
- else if (strcmp(name, "amb") == 0)
- attr = PyFloat_FromDouble((double)self->material->amb);
- else if (strcmp(name, "emit") == 0)
- attr = PyFloat_FromDouble((double)self->material->emit);
- else if (strcmp(name, "alpha") == 0)
- attr = PyFloat_FromDouble((double)self->material->alpha);
- else if (strcmp(name, "ref") == 0)
- attr = PyFloat_FromDouble((double)self->material->ref);
- else if (strcmp(name, "spec") == 0)
- attr = PyFloat_FromDouble((double)self->material->spec);
- else if (strcmp(name, "specTransp") == 0)
- attr = PyFloat_FromDouble((double)self->material->spectra);
- else if (strcmp(name, "add") == 0)
- attr = PyFloat_FromDouble((double)self->material->add);
- else if (strcmp(name, "zOffset") == 0)
- attr = PyFloat_FromDouble((double)self->material->zoffs);
- else if (strcmp(name, "haloSize") == 0)
- attr = PyFloat_FromDouble((double)self->material->hasize);
- else if (strcmp(name, "haloSeed") == 0)
- attr = PyInt_FromLong((double)self->material->seed1);
- else if (strcmp(name, "flareSize") == 0)
- attr = PyFloat_FromDouble((double)self->material->flaresize);
- else if (strcmp(name, "flareBoost") == 0)
- attr = PyFloat_FromDouble((double)self->material->flareboost);
- else if (strcmp(name, "flareSeed") == 0)
- attr = PyInt_FromLong((double)self->material->seed2);
- else if (strcmp(name, "subSize") == 0)
- attr = PyFloat_FromDouble((double)self->material->subsize);
- else if (strcmp(name, "hard") == 0)
- attr = PyInt_FromLong((long)self->material->har);
- else if (strcmp(name, "nFlares") == 0)
- attr = PyInt_FromLong((long)self->material->flarec);
- else if (strcmp(name, "nStars") == 0)
- attr = PyInt_FromLong((long)self->material->starc);
- else if (strcmp(name, "nLines") == 0)
- attr = PyInt_FromLong((long)self->material->linec);
- else if (strcmp(name, "nRings") == 0)
- attr = PyInt_FromLong((long)self->material->ringc);
-
- else if (strcmp(name, "__members__") == 0) {
- attr = /* 27 items */
- Py_BuildValue("[s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s]",
- "name", "mode", "rgbCol", "specCol", "mirCol",
- "R", "G", "B", "alpha", "amb", "emit", "ref", "spec",
- "specTransp", "add", "zOffset", "haloSize", "haloSeed",
- "flareSize", "flareBoost", "flareSeed", "subSize", "hard",
- "nFlares", "nStars", "nLines", "nRings");
- }
-
- if (!attr)
- return (EXPP_ReturnPyObjError (PyExc_MemoryError,
- "couldn't create PyObject"));
-
- if (attr != Py_None) return attr; /* member attribute found, return it */
-
- /* not an attribute, search the methods table */
- return Py_FindMethod(BPy_Material_methods, (PyObject *)self, name);
+ PyObject *attr = Py_None;
+
+ if (strcmp(name, "name") == 0)
+ attr = PyString_FromString(self->material->id.name+2);
+ else if (strcmp(name, "mode") == 0)
+ attr = PyInt_FromLong(self->material->mode);
+ else if (strcmp(name, "rgbCol") == 0)
+ attr = Material_getRGBCol(self);
+/* else if (strcmp(name, "ambCol") == 0)
+ attr = Material_getAmbCol(self);*/
+ else if (strcmp(name, "specCol") == 0)
+ attr = Material_getSpecCol(self);
+ else if (strcmp(name, "mirCol") == 0)
+ attr = Material_getMirCol(self);
+ else if (strcmp(name, "R") == 0)
+ attr = PyFloat_FromDouble((double)self->material->r);
+ else if (strcmp(name, "G") == 0)
+ attr = PyFloat_FromDouble((double)self->material->g);
+ else if (strcmp(name, "B") == 0)
+ attr = PyFloat_FromDouble((double)self->material->b);
+ else if (strcmp(name, "specR") == 0)
+ attr = PyFloat_FromDouble((double)self->material->specr);
+ else if (strcmp(name, "specG") == 0)
+ attr = PyFloat_FromDouble((double)self->material->specg);
+ else if (strcmp(name, "specB") == 0)
+ attr = PyFloat_FromDouble((double)self->material->specb);
+ else if (strcmp(name, "amb") == 0)
+ attr = PyFloat_FromDouble((double)self->material->amb);
+ else if (strcmp(name, "emit") == 0)
+ attr = PyFloat_FromDouble((double)self->material->emit);
+ else if (strcmp(name, "alpha") == 0)
+ attr = PyFloat_FromDouble((double)self->material->alpha);
+ else if (strcmp(name, "ref") == 0)
+ attr = PyFloat_FromDouble((double)self->material->ref);
+ else if (strcmp(name, "spec") == 0)
+ attr = PyFloat_FromDouble((double)self->material->spec);
+ else if (strcmp(name, "specTransp") == 0)
+ attr = PyFloat_FromDouble((double)self->material->spectra);
+ else if (strcmp(name, "add") == 0)
+ attr = PyFloat_FromDouble((double)self->material->add);
+ else if (strcmp(name, "zOffset") == 0)
+ attr = PyFloat_FromDouble((double)self->material->zoffs);
+ else if (strcmp(name, "haloSize") == 0)
+ attr = PyFloat_FromDouble((double)self->material->hasize);
+ else if (strcmp(name, "haloSeed") == 0)
+ attr = PyInt_FromLong((double)self->material->seed1);
+ else if (strcmp(name, "flareSize") == 0)
+ attr = PyFloat_FromDouble((double)self->material->flaresize);
+ else if (strcmp(name, "flareBoost") == 0)
+ attr = PyFloat_FromDouble((double)self->material->flareboost);
+ else if (strcmp(name, "flareSeed") == 0)
+ attr = PyInt_FromLong((double)self->material->seed2);
+ else if (strcmp(name, "subSize") == 0)
+ attr = PyFloat_FromDouble((double)self->material->subsize);
+ else if (strcmp(name, "hard") == 0)
+ attr = PyInt_FromLong((long)self->material->har);
+ else if (strcmp(name, "nFlares") == 0)
+ attr = PyInt_FromLong((long)self->material->flarec);
+ else if (strcmp(name, "nStars") == 0)
+ attr = PyInt_FromLong((long)self->material->starc);
+ else if (strcmp(name, "nLines") == 0)
+ attr = PyInt_FromLong((long)self->material->linec);
+ else if (strcmp(name, "nRings") == 0)
+ attr = PyInt_FromLong((long)self->material->ringc);
+
+ else if (strcmp(name, "__members__") == 0) {
+ attr = /* 27 items */
+ Py_BuildValue("[s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s]",
+ "name", "mode", "rgbCol", "specCol", "mirCol",
+ "R", "G", "B", "alpha", "amb", "emit", "ref", "spec",
+ "specTransp", "add", "zOffset", "haloSize", "haloSeed",
+ "flareSize", "flareBoost", "flareSeed", "subSize", "hard",
+ "nFlares", "nStars", "nLines", "nRings");
+ }
+
+ if (!attr)
+ return (EXPP_ReturnPyObjError (PyExc_MemoryError,
+ "couldn't create PyObject"));
+
+ if (attr != Py_None) return attr; /* member attribute found, return it */
+
+ /* not an attribute, search the methods table */
+ return Py_FindMethod(BPy_Material_methods, (PyObject *)self, name);
}
/****************************************************************************/
-/* Function: Material_setAttr */
-/* Description: This is a callback function for the BPy_Material type. */
-/* It is the function that sets Material attributes (member */
-/* variables). */
+/* Function: Material_setAttr */
+/* Description: This is a callback function for the BPy_Material type. */
+/* It is the function that sets Material attributes (member */
+/* variables). */
/****************************************************************************/
static int Material_setAttr (BPy_Material *self, char *name, PyObject *value)
{
- PyObject *valtuple;
- PyObject *error = NULL;
+ PyObject *valtuple;
+ PyObject *error = NULL;
-/* We're playing a trick on the Python API users here. Even if they use
+/* We're playing a trick on the Python API users here. Even if they use
* Material.member = val instead of Material.setMember(val), we end up using the
* function anyway, since it already has error checking, clamps to the right
* interval and updates the Blender Material structure when necessary. */
/* First we put "value" in a tuple, because we want to pass it to functions
* that only accept PyTuples. */
- valtuple = Py_BuildValue("(O)", value);
+ valtuple = Py_BuildValue("(O)", value);
- if (!valtuple) /* everything OK with our PyObject? */
- return EXPP_ReturnIntError(PyExc_MemoryError,
- "MaterialSetAttr: couldn't create PyTuple");
+ if (!valtuple) /* everything OK with our PyObject? */
+ return EXPP_ReturnIntError(PyExc_MemoryError,
+ "MaterialSetAttr: couldn't create PyTuple");
/* Now we just compare "name" with all possible BPy_Material member variables */
- if (strcmp (name, "name") == 0)
- error = Material_setName (self, valtuple);
- else if (strcmp (name, "mode") == 0)
- error = Material_setIntMode (self, valtuple); /* special case */
- else if (strcmp (name, "rgbCol") == 0)
- error = Material_setRGBCol (self, valtuple);
-/* else if (strcmp (name, "ambCol") == 0)
- error = Material_setAmbCol (self, valtuple);*/
- else if (strcmp (name, "specCol") == 0)
- error = Material_setSpecCol (self, valtuple);
- else if (strcmp (name, "mirCol") == 0)
- error = Material_setMirCol (self, valtuple);
- else if (strcmp (name, "R") == 0)
- error = Material_setColorComponent (self, "R", valtuple);
- else if (strcmp (name, "G") == 0)
- error = Material_setColorComponent (self, "G", valtuple);
- else if (strcmp (name, "B") == 0)
- error = Material_setColorComponent (self, "B", valtuple);
- else if (strcmp (name, "specR") == 0)
- error = Material_setColorComponent (self, "specR", valtuple);
- else if (strcmp (name, "specG") == 0)
- error = Material_setColorComponent (self, "specG", valtuple);
- else if (strcmp (name, "specB") == 0)
- error = Material_setColorComponent (self, "specB", valtuple);
- else if (strcmp (name, "amb") == 0)
- error = Material_setAmb (self, valtuple);
- else if (strcmp (name, "emit") == 0)
- error = Material_setEmit (self, valtuple);
- else if (strcmp (name, "alpha") == 0)
- error = Material_setAlpha (self, valtuple);
- else if (strcmp (name, "ref") == 0)
- error = Material_setRef (self, valtuple);
- else if (strcmp (name, "spec") == 0)
- error = Material_setSpec (self, valtuple);
- else if (strcmp (name, "specTransp") == 0)
- error = Material_setSpecTransp (self, valtuple);
- else if (strcmp (name, "add") == 0)
- error = Material_setAdd (self, valtuple);
- else if (strcmp (name, "zOffset") == 0)
- error = Material_setZOffset (self, valtuple);
- else if (strcmp (name, "haloSize") == 0)
- error = Material_setHaloSize (self, valtuple);
- else if (strcmp (name, "haloSeed") == 0)
- error = Material_setHaloSeed (self, valtuple);
- else if (strcmp (name, "flareSize") == 0)
- error = Material_setFlareSize (self, valtuple);
- else if (strcmp (name, "flareBoost") == 0)
- error = Material_setFlareBoost (self, valtuple);
- else if (strcmp (name, "flareSeed") == 0)
- error = Material_setFlareSeed (self, valtuple);
- else if (strcmp (name, "subSize") == 0)
- error = Material_setSubSize (self, valtuple);
- else if (strcmp (name, "hard") == 0)
- error = Material_setHardness (self, valtuple);
- else if (strcmp (name, "nFlares") == 0)
- error = Material_setNFlares (self, valtuple);
- else if (strcmp (name, "nStars") == 0)
- error = Material_setNStars (self, valtuple);
- else if (strcmp (name, "nLines") == 0)
- error = Material_setNLines (self, valtuple);
- else if (strcmp (name, "nRings") == 0)
- error = Material_setNRings (self, valtuple);
-
- else { /* Error */
- Py_DECREF(valtuple);
- return (EXPP_ReturnIntError (PyExc_AttributeError, name));
- }
+ if (strcmp (name, "name") == 0)
+ error = Material_setName (self, valtuple);
+ else if (strcmp (name, "mode") == 0)
+ error = Material_setIntMode (self, valtuple); /* special case */
+ else if (strcmp (name, "rgbCol") == 0)
+ error = Material_setRGBCol (self, valtuple);
+/* else if (strcmp (name, "ambCol") == 0)
+ error = Material_setAmbCol (self, valtuple);*/
+ else if (strcmp (name, "specCol") == 0)
+ error = Material_setSpecCol (self, valtuple);
+ else if (strcmp (name, "mirCol") == 0)
+ error = Material_setMirCol (self, valtuple);
+ else if (strcmp (name, "R") == 0)
+ error = Material_setColorComponent (self, "R", valtuple);
+ else if (strcmp (name, "G") == 0)
+ error = Material_setColorComponent (self, "G", valtuple);
+ else if (strcmp (name, "B") == 0)
+ error = Material_setColorComponent (self, "B", valtuple);
+ else if (strcmp (name, "specR") == 0)
+ error = Material_setColorComponent (self, "specR", valtuple);
+ else if (strcmp (name, "specG") == 0)
+ error = Material_setColorComponent (self, "specG", valtuple);
+ else if (strcmp (name, "specB") == 0)
+ error = Material_setColorComponent (self, "specB", valtuple);
+ else if (strcmp (name, "amb") == 0)
+ error = Material_setAmb (self, valtuple);
+ else if (strcmp (name, "emit") == 0)
+ error = Material_setEmit (self, valtuple);
+ else if (strcmp (name, "alpha") == 0)
+ error = Material_setAlpha (self, valtuple);
+ else if (strcmp (name, "ref") == 0)
+ error = Material_setRef (self, valtuple);
+ else if (strcmp (name, "spec") == 0)
+ error = Material_setSpec (self, valtuple);
+ else if (strcmp (name, "specTransp") == 0)
+ error = Material_setSpecTransp (self, valtuple);
+ else if (strcmp (name, "add") == 0)
+ error = Material_setAdd (self, valtuple);
+ else if (strcmp (name, "zOffset") == 0)
+ error = Material_setZOffset (self, valtuple);
+ else if (strcmp (name, "haloSize") == 0)
+ error = Material_setHaloSize (self, valtuple);
+ else if (strcmp (name, "haloSeed") == 0)
+ error = Material_setHaloSeed (self, valtuple);
+ else if (strcmp (name, "flareSize") == 0)
+ error = Material_setFlareSize (self, valtuple);
+ else if (strcmp (name, "flareBoost") == 0)
+ error = Material_setFlareBoost (self, valtuple);
+ else if (strcmp (name, "flareSeed") == 0)
+ error = Material_setFlareSeed (self, valtuple);
+ else if (strcmp (name, "subSize") == 0)
+ error = Material_setSubSize (self, valtuple);
+ else if (strcmp (name, "hard") == 0)
+ error = Material_setHardness (self, valtuple);
+ else if (strcmp (name, "nFlares") == 0)
+ error = Material_setNFlares (self, valtuple);
+ else if (strcmp (name, "nStars") == 0)
+ error = Material_setNStars (self, valtuple);
+ else if (strcmp (name, "nLines") == 0)
+ error = Material_setNLines (self, valtuple);
+ else if (strcmp (name, "nRings") == 0)
+ error = Material_setNRings (self, valtuple);
+
+ else { /* Error */
+ Py_DECREF(valtuple);
+ return (EXPP_ReturnIntError (PyExc_AttributeError, name));
+ }
/* valtuple won't be returned to the caller, so we need to DECREF it */
- Py_DECREF(valtuple);
+ Py_DECREF(valtuple);
- if (error != Py_None) return -1;
+ if (error != Py_None) return -1;
/* Py_None was incref'ed by the called Material_set* function. We probably
* don't need to decref Py_None (!), but since Python/C API manual tells us
* to treat it like any other PyObject regarding ref counting ... */
- Py_DECREF(Py_None);
- return 0; /* normal exit */
+ Py_DECREF(Py_None);
+ return 0; /* normal exit */
}
/*****************************************************************************/
-/* Function: Material_repr */
-/* Description: This is a callback function for the BPy_Material type. It */
-/* builds a meaninful string to represent material objects. */
+/* Function: Material_repr */
+/* Description: This is a callback function for the BPy_Material type. It */
+/* builds a meaninful string to represent material objects. */
/*****************************************************************************/
static PyObject *Material_repr (BPy_Material *self)
{
- return PyString_FromFormat ("[Material \"%s\"]", self->material->id.name+2);
+ return PyString_FromFormat ("[Material \"%s\"]", self->material->id.name+2);
}
/*****************************************************************************/
-/* These functions are used in NMesh.c and Object.c */
+/* These functions are used in NMesh.c and Object.c */
/*****************************************************************************/
PyObject *EXPP_PyList_fromMaterialList (Material **matlist, int len)
{
- PyObject *list;
- int i;
+ PyObject *list;
+ int i;
- list = PyList_New(0);
- if (!matlist) return list;
+ list = PyList_New(0);
+ if (!matlist) return list;
- for (i = 0; i < len; i++) {
- Material *mat = matlist[i];
- PyObject *ob;
+ for (i = 0; i < len; i++) {
+ Material *mat = matlist[i];
+ PyObject *ob;
- if (mat) {
- ob = Material_CreatePyObject (mat);
- PyList_Append (list, ob);
- Py_DECREF (ob); /* because Append increfs */
- }
- }
+ if (mat) {
+ ob = Material_CreatePyObject (mat);
+ PyList_Append (list, ob);
+ Py_DECREF (ob); /* because Append increfs */
+ }
+ }
- return list;
+ return list;
}
Material **EXPP_newMaterialList_fromPyList (PyObject *list)
{
- int i, len;
- BPy_Material *pymat = 0;
- Material *mat;
- Material **matlist;
+ int i, len;
+ BPy_Material *pymat = 0;
+ Material *mat;
+ Material **matlist;
- len = PySequence_Length (list);
- if (len > 16) len = 16;
+ len = PySequence_Length (list);
+ if (len > 16) len = 16;
- matlist = EXPP_newMaterialList (len);
+ matlist = EXPP_newMaterialList (len);
- for (i= 0; i < len; i++) {
+ for (i= 0; i < len; i++) {
- pymat = (BPy_Material *)PySequence_GetItem (list, i);
+ pymat = (BPy_Material *)PySequence_GetItem (list, i);
- if (Material_CheckPyObject ((PyObject *)pymat)) {
- mat = pymat->material;
- matlist[i] = mat;
- }
+ if (Material_CheckPyObject ((PyObject *)pymat)) {
+ mat = pymat->material;
+ matlist[i] = mat;
+ }
- else { /* error; illegal type in material list */
- Py_DECREF(pymat);
- MEM_freeN(matlist);
- return NULL;
- }
+ else { /* error; illegal type in material list */
+ Py_DECREF(pymat);
+ MEM_freeN(matlist);
+ return NULL;
+ }
- Py_DECREF(pymat);
- }
+ Py_DECREF(pymat);
+ }
- return matlist;
+ return matlist;
}
Material **EXPP_newMaterialList(int len)
{
- Material **matlist =
- (Material **)MEM_mallocN(len * sizeof(Material *), "MaterialList");
+ Material **matlist =
+ (Material **)MEM_mallocN(len * sizeof(Material *), "MaterialList");
- return matlist;
+ return matlist;
}
int EXPP_releaseMaterialList (Material **matlist, int len)
{
- int i;
- Material * mat;
+ int i;
+ Material * mat;
- if ((len < 0) || (len > MAXMAT)) {
- printf ("illegal matindex!\n");
- return 0;
- }
+ if ((len < 0) || (len > MAXMAT)) {
+ printf ("illegal matindex!\n");
+ return 0;
+ }
- for (i=0 ; i<len ; i++) {
- mat = matlist[i];
- if (mat != NULL) {
- if (((ID *)mat)->us > 0)
- ((ID *)mat)->us--;
- else
- printf ("FATAL: material usage=0: %s", ((ID *)mat)->name);
- }
- }
- MEM_freeN (matlist);
+ for (i=0 ; i<len ; i++) {
+ mat = matlist[i];
+ if (mat != NULL) {
+ if (((ID *)mat)->us > 0)
+ ((ID *)mat)->us--;
+ else
+ printf ("FATAL: material usage=0: %s", ((ID *)mat)->name);
+ }
+ }
+ MEM_freeN (matlist);
- return 1;
+ return 1;
}
/** expands pointer array of length 'oldsize' to length 'newsize'.
- * A pointer to the (void *) array must be passed as first argument
- * The array pointer content can be NULL, in this case a new array of length
- * 'newsize' is created.
- */
+ * A pointer to the (void *) array must be passed as first argument
+ * The array pointer content can be NULL, in this case a new array of length
+ * 'newsize' is created.
+ */
static int expandPtrArray(void **p, int oldsize, int newsize)
{
@@ -1598,28 +1602,28 @@ static int expandPtrArray(void **p, int oldsize, int newsize)
int EXPP_synchronizeMaterialLists (Object *object, void *data)
{
- Material *** p_dataMaterials = give_matarar (object);
- short * nmaterials = give_totcolp (object);
-
- if (object->totcol > *nmaterials) {
- /* More object mats than data mats */
- *nmaterials = object->totcol;
- return expandPtrArray ((void *) p_dataMaterials,
- *nmaterials,
- object->totcol);
- }
- else {
- if (object->totcol < *nmaterials) {
- /* More data mats than object mats */
- object->totcol = *nmaterials;
- return expandPtrArray ((void *) &object->mat,
- object->totcol,
- *nmaterials);
- }
- }
-
- /* No synchronization is needed; they're of equal length */
- return 1;
+ Material *** p_dataMaterials = give_matarar (object);
+ short * nmaterials = give_totcolp (object);
+
+ if (object->totcol > *nmaterials) {
+ /* More object mats than data mats */
+ *nmaterials = object->totcol;
+ return expandPtrArray ((void *) p_dataMaterials,
+ *nmaterials,
+ object->totcol);
+ }
+ else {
+ if (object->totcol < *nmaterials) {
+ /* More data mats than object mats */
+ object->totcol = *nmaterials;
+ return expandPtrArray ((void *) &object->mat,
+ object->totcol,
+ *nmaterials);
+ }
+ }
+
+ /* No synchronization is needed; they're of equal length */
+ return 1;
}
void EXPP_incr_mats_us (Material **matlist, int len)
diff --git a/source/blender/python/api2_2x/NMesh.c b/source/blender/python/api2_2x/NMesh.c
index bae9faa42ea6218a5794f8c72949afd3295f37f7..d76d45de2e7a6198c8f79421259f5c4407932395 100644
--- a/source/blender/python/api2_2x/NMesh.c
+++ b/source/blender/python/api2_2x/NMesh.c
@@ -31,7 +31,13 @@
#include "NMesh.h"
-#define NMESH_FRAME_MAX 18000
+#define NMESH_FRAME_MAX 18000
+#define NMESH_SMOOTHRESH 30
+#define NMESH_SMOOTHRESH_MIN 1
+#define NMESH_SMOOTHRESH_MAX 80
+#define NMESH_SUBDIV 1
+#define NMESH_SUBDIV_MIN 1
+#define NMESH_SUBDIV_MAX 6
void mesh_update(Mesh *mesh)
{
@@ -944,6 +950,61 @@ PyObject *NMesh_link(PyObject *self, PyObject *args)
return EXPP_incr_ret(Py_None);
}
+static PyObject *NMesh_getMaxSmoothAngle (BPy_NMesh *self)
+{
+ PyObject *attr = PyInt_FromLong (self->smoothresh);
+
+ if (attr) return attr;
+
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get NMesh.maxSmoothAngle attribute");
+}
+
+static PyObject *NMesh_setMaxSmoothAngle (PyObject *self, PyObject *args)
+{
+ short value = 0;
+ BPy_NMesh *nmesh = (BPy_NMesh *)self;
+
+ if (!PyArg_ParseTuple(args, "h", &value))
+ return EXPP_ReturnPyObjError (PyExc_AttributeError,
+ "expected an int in [1, 80] as argument");
+
+ nmesh->smoothresh =
+ (short)EXPP_ClampInt (value, NMESH_SMOOTHRESH_MIN, NMESH_SMOOTHRESH_MAX);
+
+ Py_INCREF (Py_None);
+ return Py_None;
+}
+
+static PyObject *NMesh_getSubDivLevels (BPy_NMesh *self)
+{
+ PyObject *attr = Py_BuildValue ("[h,h]", self->subdiv[0], self->subdiv[1]);
+
+ if (attr) return attr;
+
+ return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+ "couldn't get NMesh.subDivLevels attribute");
+}
+
+static PyObject *NMesh_setSubDivLevels (PyObject *self, PyObject *args)
+{
+ short display = 0, render = 0;
+ BPy_NMesh *nmesh = (BPy_NMesh *)self;
+
+ if (!PyArg_ParseTuple(args, "(hh)", &display, &render))
+ return EXPP_ReturnPyObjError (PyExc_AttributeError,
+ "expected a sequence [int, int] as argument");
+
+ nmesh->subdiv[0] =
+ (short)EXPP_ClampInt (display, NMESH_SUBDIV_MIN, NMESH_SUBDIV_MAX);
+
+ nmesh->subdiv[1] =
+ (short)EXPP_ClampInt (render, NMESH_SUBDIV_MIN, NMESH_SUBDIV_MAX);
+
+ Py_INCREF (Py_None);
+ return Py_None;
+}
+
static PyObject *NMesh_getMode (BPy_NMesh *self)
{
PyObject *attr = PyInt_FromLong (self->mode);
@@ -1005,8 +1066,14 @@ static struct PyMethodDef NMesh_methods[] =
MethodDef(insertKey),
MethodDef(removeAllKeys),
MethodDef(update),
- {"getMode", (PyCFunction)NMesh_getMode, METH_NOARGS, NMesh_getMode_doc},
MethodDef(setMode),
+ MethodDef(setMaxSmoothAngle),
+ MethodDef(setSubDivLevels),
+ {"getMode", (PyCFunction)NMesh_getMode, METH_NOARGS, NMesh_getMode_doc},
+ {"getMaxSmoothAngle", (PyCFunction)NMesh_getMaxSmoothAngle, METH_NOARGS,
+ NMesh_getMaxSmoothAngle_doc},
+ {"getSubDivLevels", (PyCFunction)NMesh_getSubDivLevels, METH_NOARGS,
+ NMesh_getSubDivLevels_doc},
{NULL, NULL}
};
@@ -1029,6 +1096,12 @@ static PyObject *NMesh_getattr(PyObject *self, char *name)
else if (strcmp(name, "verts") == 0)
return EXPP_incr_ret(me->verts);
+ else if (strcmp(name, "maxSmoothAngle") == 0)
+ return PyInt_FromLong(me->smoothresh);
+
+ else if (strcmp(name, "subDivLevels") == 0)
+ return Py_BuildValue("[h,h]", me->subdiv[0], me->subdiv[1]);
+
else if (strcmp(name, "users") == 0) {
if (me->mesh) {
return PyInt_FromLong(me->mesh->id.us);
@@ -1042,8 +1115,9 @@ static PyObject *NMesh_getattr(PyObject *self, char *name)
return EXPP_incr_ret(me->faces);
else if (strcmp(name, "__members__") == 0)
- return Py_BuildValue("[s,s,s,s,s]",
- "name", "materials", "verts", "users", "faces");
+ return Py_BuildValue("[s,s,s,s,s,s,s]",
+ "name", "materials", "verts", "users", "faces", "maxSmoothAngle",
+ "subdivLevels");
return Py_FindMethod(NMesh_methods, (PyObject*)self, name);
}
@@ -1099,6 +1173,47 @@ static int NMesh_setattr(PyObject *self, char *name, PyObject *v)
return EXPP_ReturnIntError (PyExc_TypeError, "expected a sequence");
}
+ else if (!strcmp(name, "maxSmoothAngle")) {
+ short smoothresh = 0;
+
+ if (!PyInt_Check(v))
+ return EXPP_ReturnIntError (PyExc_TypeError,
+ "expected int argument");
+
+ smoothresh = (short)PyInt_AsLong(v);
+
+ me->smoothresh =
+ EXPP_ClampInt(smoothresh, NMESH_SMOOTHRESH_MIN, NMESH_SMOOTHRESH_MAX);
+ }
+
+ else if (!strcmp(name, "subDivLevels")) {
+ int subdiv[2] = {0,0};
+ int i;
+ PyObject *tmp;
+
+ if (!PySequence_Check(v) || (PySequence_Length(v) != 2))
+ return EXPP_ReturnIntError (PyExc_TypeError,
+ "expected a list [int, int] as argument");
+
+ for (i = 0; i < 2; i++) {
+ tmp = PySequence_GetItem(v, i);
+ if (tmp) {
+ if (!PyInt_Check(tmp)) {
+ Py_DECREF (tmp);
+ return EXPP_ReturnIntError (PyExc_TypeError,
+ "expected a list [int, int] as argument");
+ }
+
+ subdiv[i] = PyInt_AsLong (tmp);
+ me->subdiv[i] =
+ (short)EXPP_ClampInt(subdiv[i], NMESH_SUBDIV_MIN, NMESH_SUBDIV_MAX);
+ Py_DECREF (tmp);
+ }
+ else return EXPP_ReturnIntError (PyExc_RuntimeError,
+ "couldn't retrieve subdiv values from list");
+ }
+ }
+
else
return EXPP_ReturnIntError (PyExc_AttributeError, name);
@@ -1241,6 +1356,10 @@ static PyObject *new_NMesh_internal(Mesh *oldmesh,
{
BPy_NMesh *me = PyObject_NEW (BPy_NMesh, &NMesh_Type);
me->flags = 0;
+ me->subdiv[0] = NMESH_SUBDIV;
+ me->subdiv[1] = NMESH_SUBDIV;
+ me->smoothresh = NMESH_SMOOTHRESH;
+
me->object = NULL; /* not linked to any object yet */
if (!oldmesh) {
@@ -1276,7 +1395,10 @@ static PyObject *new_NMesh_internal(Mesh *oldmesh,
else {
me->name = PyString_FromString(oldmesh->id.name+2);
me->mesh = oldmesh;
- me->mode = oldmesh->flag; /* yes, we save the mesh flags in nmesh->mode */
+ me->mode = oldmesh->flag; /* yes, we save the mesh flags in nmesh->mode*/
+ me->subdiv[0] = oldmesh->subdiv;
+ me->subdiv[1] = oldmesh->subdivr;
+ me->smoothresh = oldmesh->smoothresh;
mfaceints = NULL;
msticky = oldmesh->msticky;
@@ -1703,8 +1825,12 @@ static int convert_NMeshToMesh (Mesh *mesh, BPy_NMesh *nmesh)
mesh->tface = NULL;
mesh->mat = NULL;
- /* Minor note: we used 'mode' because 'flag' was already used internally by nmesh */
+ /* Minor note: we used 'mode' because 'flag' was already used internally
+ * by nmesh */
mesh->flag = nmesh->mode;
+ mesh->smoothresh = nmesh->smoothresh;
+ mesh->subdiv = nmesh->subdiv[0];
+ mesh->subdivr = nmesh->subdiv[1];
/*@ material assignment moved to PutRaw */
mesh->totvert = PySequence_Length(nmesh->verts);
diff --git a/source/blender/python/api2_2x/NMesh.h b/source/blender/python/api2_2x/NMesh.h
index 492760b02a970f991e91fd7b47913ddce1487476..4d0d0253fa111d4b0ac561f641d63067234ee7a0 100644
--- a/source/blender/python/api2_2x/NMesh.h
+++ b/source/blender/python/api2_2x/NMesh.h
@@ -208,6 +208,20 @@ static char NMesh_setMode_doc[] =
"(none to 4 strings) - set the mode flags of this nmesh.\n\
() - unset all flags.";
+static char NMesh_getMaxSmoothAngle_doc[] =
+"() - get the max smooth angle for mesh auto smoothing.";
+
+static char NMesh_setMaxSmoothAngle_doc[] =
+"(int) - set the max smooth angle for mesh auto smoothing in the range\n\
+[1,80] in degrees.";
+
+static char NMesh_getSubDivLevels_doc[] =
+"() - get the subdivision levels for display and rendering: [display, render]";
+
+static char NMesh_setSubDivLevels_doc[] =
+"([int, int]) - set the subdivision levels for [display, render] -- they are\n\
+clamped to the range [1,6].";
+
static char M_NMesh_New_doc[] =
"() - returns a new, empty NMesh mesh object\n";
@@ -271,6 +285,8 @@ typedef struct {
PyObject *verts;
PyObject *faces;
int sel_face; /*@ XXX remove */
+ short smoothresh; /* max AutoSmooth angle */
+ short subdiv[2]; /* SubDiv Levels: display and rendering */
short mode; /* see the EXPP_NMESH_* defines in the beginning of this file */
char flags;
diff --git a/source/blender/python/api2_2x/Object.c b/source/blender/python/api2_2x/Object.c
index dd93e4114b0750106ee6daada07d8630171d3ab3..170cfa61f4b947c118477ac88e6ab848eecede82 100644
--- a/source/blender/python/api2_2x/Object.c
+++ b/source/blender/python/api2_2x/Object.c
@@ -1236,6 +1236,10 @@ static PyObject *Object_shareFrom (BPy_Object *self, PyObject *args)
switch (self->object->type)
{
case OB_MESH:
+ case OB_LAMP:
+ case OB_CAMERA: /* we can probably add the other types, too */
+ case OB_ARMATURE:
+ case OB_CURVE:
oldid = (ID*) self->object->data;
id = (ID*) object->object->data;
self->object->data = object->object->data;
diff --git a/source/blender/python/api2_2x/doc/NMesh.py b/source/blender/python/api2_2x/doc/NMesh.py
index 0fc0e434a7d6668e544fb33111537e69a14c2b6f..900821303f9f91c3cc364c5e46ac2fcbb91fa1a6 100644
--- a/source/blender/python/api2_2x/doc/NMesh.py
+++ b/source/blender/python/api2_2x/doc/NMesh.py
@@ -232,7 +232,9 @@ class NMesh:
@cvar verts: The list of NMesh vertices (NMVerts).
@cvar users: The number of Objects using (linked to) this mesh.
@cvar faces: The list of NMesh faces (NMFaces).
- @cvar mode: The mode flags for this mesh. See L{setMode}
+ @cvar mode: The mode flags for this mesh. See L{setMode}.
+ @cvar subDivLevels: The [display, rendering] subdivision levels in [1, 6].
+ @cvar maxSmoothAngle: The max angle for auto smoothing. See L{setMode}.
"""
def addMaterial(material):
@@ -483,4 +485,31 @@ class NMesh:
@type vertList: list of ints
@param vertList: if given, only those vertex points that are both in the
list and group passed in are returned.
- """
+ """
+
+ def getMaxSmoothAngle():
+ """
+ Get the max angle for auto smoothing.
+ @return: The value in degrees.
+ """
+
+ def setMaxSmoothAngle(angle):
+ """
+ Set the max angle for auto smoothing.
+ @type angle: int
+ @param angle: The new value in degrees -- it's clamped to [1, 80].
+ """
+
+ def getSubDivLevels():
+ """
+ Get the mesh subdivision levels for realtime display and rendering.
+ @return: list of ints: [display, render].
+ """
+
+ def setSubDivLevels(subdiv):
+ """
+ Set the mesh subdivision levels for realtime display and rendering.
+ @type subdiv: list of 2 ints
+ @param subdiv: new subdiv levels: [display, render]. Both are clamped to
+ lie in the range [1, 6].
+ """