forked from bartvdbraak/blender
C, style changes (mostly white space edits), no functional change.
This commit is contained in:
parent
ff1656175a
commit
cadc1218c8
@ -316,10 +316,12 @@ const char *BPy_IDProperty_Map_ValidateAndCreate(const char *name, IDProperty *g
|
||||
if (PyFloat_Check(ob)) {
|
||||
val.d = PyFloat_AsDouble(ob);
|
||||
prop = IDP_New(IDP_DOUBLE, val, name);
|
||||
} else if (PyLong_Check(ob)) {
|
||||
}
|
||||
else if (PyLong_Check(ob)) {
|
||||
val.i = (int) PyLong_AsSsize_t(ob);
|
||||
prop = IDP_New(IDP_INT, val, name);
|
||||
} else if (PyUnicode_Check(ob)) {
|
||||
}
|
||||
else if (PyUnicode_Check(ob)) {
|
||||
#ifdef USE_STRING_COERCE
|
||||
PyObject *value_coerce= NULL;
|
||||
val.str = (char *)PyC_UnicodeAsByte(ob, &value_coerce);
|
||||
@ -329,7 +331,8 @@ const char *BPy_IDProperty_Map_ValidateAndCreate(const char *name, IDProperty *g
|
||||
val.str = _PyUnicode_AsString(ob);
|
||||
prop = IDP_New(IDP_STRING, val, name);
|
||||
#endif
|
||||
} else if (PySequence_Check(ob)) {
|
||||
}
|
||||
else if (PySequence_Check(ob)) {
|
||||
PyObject *item;
|
||||
int i;
|
||||
|
||||
@ -372,7 +375,8 @@ const char *BPy_IDProperty_Map_ValidateAndCreate(const char *name, IDProperty *g
|
||||
}
|
||||
break;
|
||||
}
|
||||
} else if (PyMapping_Check(ob)) {
|
||||
}
|
||||
else if (PyMapping_Check(ob)) {
|
||||
PyObject *keys, *vals, *key, *pval;
|
||||
int i, len;
|
||||
/*yay! we get into recursive stuff now!*/
|
||||
@ -409,13 +413,15 @@ const char *BPy_IDProperty_Map_ValidateAndCreate(const char *name, IDProperty *g
|
||||
}
|
||||
Py_XDECREF(keys);
|
||||
Py_XDECREF(vals);
|
||||
} else return "invalid property value";
|
||||
}
|
||||
else return "invalid property value";
|
||||
|
||||
if(group->type==IDP_IDPARRAY) {
|
||||
IDP_AppendArray(group, prop);
|
||||
// IDP_FreeProperty(item); // IDP_AppendArray does a shallow copy (memcpy), only free memory
|
||||
MEM_freeN(prop);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
IDP_ReplaceInGroup(group, prop);
|
||||
}
|
||||
|
||||
@ -436,7 +442,8 @@ int BPy_Wrap_SetMapItem(IDProperty *prop, PyObject *key, PyObject *val)
|
||||
IDP_FreeProperty(pkey);
|
||||
MEM_freeN(pkey);
|
||||
return 0;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_KeyError, "property not found in group");
|
||||
return -1;
|
||||
}
|
||||
@ -507,10 +514,12 @@ static PyObject *BPy_IDGroup_MapDataToPy(IDProperty *prop)
|
||||
if (prop->subtype == IDP_FLOAT) {
|
||||
PyList_SET_ITEM(seq, i,
|
||||
PyFloat_FromDouble(((float*)prop->data.pointer)[i]));
|
||||
} else if (prop->subtype == IDP_DOUBLE) {
|
||||
}
|
||||
else if (prop->subtype == IDP_DOUBLE) {
|
||||
PyList_SET_ITEM(seq, i,
|
||||
PyFloat_FromDouble(((double*)prop->data.pointer)[i]));
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
PyList_SET_ITEM(seq, i,
|
||||
PyLong_FromLong(((int*)prop->data.pointer)[i]));
|
||||
}
|
||||
@ -1092,10 +1101,12 @@ static PyObject *BPy_Group_Iter_Next(BPy_IDGroup_Iter *self)
|
||||
PyTuple_SET_ITEM(ret, 0, PyUnicode_FromString(cur->name));
|
||||
PyTuple_SET_ITEM(ret, 1, BPy_IDGroup_WrapData(self->group->id, cur));
|
||||
return ret;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
return PyUnicode_FromString(cur->name);
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_StopIteration, "iterator at end");
|
||||
return NULL;
|
||||
}
|
||||
|
@ -170,7 +170,8 @@ Buffer *BGL_MakeBuffer(int type, int ndimensions, int *dimensions, void *initbuf
|
||||
|
||||
if (initbuffer) {
|
||||
memcpy(buffer->buf.asvoid, initbuffer, length*size);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
memset(buffer->buf.asvoid, 0, length*size);
|
||||
/*
|
||||
for (i= 0; i<length; i++) {
|
||||
@ -280,7 +281,8 @@ static PyObject *Buffer_item(PyObject *self, int i)
|
||||
case GL_FLOAT: return PyFloat_FromDouble(buf->buf.asfloat[i]);
|
||||
case GL_DOUBLE: return Py_BuildValue("d", buf->buf.asdouble[i]);
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
Buffer *newbuf;
|
||||
int j, length, size;
|
||||
|
||||
@ -350,17 +352,21 @@ static int Buffer_ass_item(PyObject *self, int i, PyObject *v)
|
||||
if (buf->type==GL_BYTE) {
|
||||
if (!PyArg_Parse(v, "b:Coordinates must be ints", &buf->buf.asbyte[i]))
|
||||
return -1;
|
||||
} else if (buf->type==GL_SHORT) {
|
||||
}
|
||||
else if (buf->type==GL_SHORT) {
|
||||
if (!PyArg_Parse(v, "h:Coordinates must be ints", &buf->buf.asshort[i]))
|
||||
return -1;
|
||||
|
||||
} else if (buf->type==GL_INT) {
|
||||
}
|
||||
else if (buf->type==GL_INT) {
|
||||
if (!PyArg_Parse(v, "i:Coordinates must be ints", &buf->buf.asint[i]))
|
||||
return -1;
|
||||
} else if (buf->type==GL_FLOAT) {
|
||||
}
|
||||
else if (buf->type==GL_FLOAT) {
|
||||
if (!PyArg_Parse(v, "f:Coordinates must be floats", &buf->buf.asfloat[i]))
|
||||
return -1;
|
||||
} else if (buf->type==GL_DOUBLE) {
|
||||
}
|
||||
else if (buf->type==GL_DOUBLE) {
|
||||
if (!PyArg_Parse(v, "d:Coordinates must be floats", &buf->buf.asdouble[i]))
|
||||
return -1;
|
||||
}
|
||||
|
@ -58,7 +58,7 @@ static Main *bpy_import_main= NULL;
|
||||
static void free_compiled_text(Text *text)
|
||||
{
|
||||
if(text->compiled) {
|
||||
Py_DECREF(( PyObject * )text->compiled);
|
||||
Py_DECREF((PyObject *)text->compiled);
|
||||
}
|
||||
text->compiled= NULL;
|
||||
}
|
||||
@ -81,23 +81,23 @@ void bpy_text_filename_get(char *fn, size_t fn_len, Text *text)
|
||||
|
||||
PyObject *bpy_text_import(Text *text)
|
||||
{
|
||||
char *buf = NULL;
|
||||
char *buf= NULL;
|
||||
char modulename[24];
|
||||
int len;
|
||||
|
||||
if( !text->compiled ) {
|
||||
if(!text->compiled) {
|
||||
char fn_dummy[256];
|
||||
bpy_text_filename_get(fn_dummy, sizeof(fn_dummy), text);
|
||||
|
||||
buf = txt_to_buf( text );
|
||||
text->compiled = Py_CompileString( buf, fn_dummy, Py_file_input );
|
||||
MEM_freeN( buf );
|
||||
buf= txt_to_buf(text);
|
||||
text->compiled= Py_CompileString(buf, fn_dummy, Py_file_input);
|
||||
MEM_freeN(buf);
|
||||
|
||||
if( PyErr_Occurred( ) ) {
|
||||
PyErr_Print( );
|
||||
PyErr_Clear( );
|
||||
if(PyErr_Occurred()) {
|
||||
PyErr_Print();
|
||||
PyErr_Clear();
|
||||
PySys_SetObject("last_traceback", NULL);
|
||||
free_compiled_text( text );
|
||||
free_compiled_text(text);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
@ -108,11 +108,11 @@ PyObject *bpy_text_import(Text *text)
|
||||
return PyImport_ExecCodeModule(modulename, text->compiled);
|
||||
}
|
||||
|
||||
PyObject *bpy_text_import_name( char *name, int *found )
|
||||
PyObject *bpy_text_import_name(char *name, int *found)
|
||||
{
|
||||
Text *text;
|
||||
char txtname[22]; /* 21+NULL */
|
||||
int namelen = strlen( name );
|
||||
int namelen= strlen(name);
|
||||
//XXX Main *maggie= bpy_import_main ? bpy_import_main:G.main;
|
||||
Main *maggie= bpy_import_main;
|
||||
|
||||
@ -125,15 +125,15 @@ PyObject *bpy_text_import_name( char *name, int *found )
|
||||
|
||||
if (namelen>21-3) return NULL; /* we know this cant be importable, the name is too long for blender! */
|
||||
|
||||
memcpy( txtname, name, namelen );
|
||||
memcpy( &txtname[namelen], ".py", 4 );
|
||||
memcpy(txtname, name, namelen);
|
||||
memcpy(&txtname[namelen], ".py", 4);
|
||||
|
||||
text= BLI_findstring(&maggie->text, txtname, offsetof(ID, name) + 2);
|
||||
|
||||
if( !text )
|
||||
if(!text)
|
||||
return NULL;
|
||||
else
|
||||
*found = 1;
|
||||
*found= 1;
|
||||
|
||||
return bpy_text_import(text);
|
||||
}
|
||||
@ -143,12 +143,12 @@ PyObject *bpy_text_import_name( char *name, int *found )
|
||||
* find in-memory module and recompile
|
||||
*/
|
||||
|
||||
PyObject *bpy_text_reimport( PyObject *module, int *found )
|
||||
PyObject *bpy_text_reimport(PyObject *module, int *found)
|
||||
{
|
||||
Text *text;
|
||||
const char *name;
|
||||
char *filepath;
|
||||
char *buf = NULL;
|
||||
char *buf= NULL;
|
||||
//XXX Main *maggie= bpy_import_main ? bpy_import_main:G.main;
|
||||
Main *maggie= bpy_import_main;
|
||||
|
||||
@ -170,50 +170,50 @@ PyObject *bpy_text_reimport( PyObject *module, int *found )
|
||||
text= BLI_findstring(&maggie->text, BLI_path_basename(filepath), offsetof(ID, name) + 2);
|
||||
|
||||
/* uh-oh.... didn't find it */
|
||||
if( !text )
|
||||
if(!text)
|
||||
return NULL;
|
||||
else
|
||||
*found = 1;
|
||||
*found= 1;
|
||||
|
||||
/* if previously compiled, free the object */
|
||||
/* (can't see how could be NULL, but check just in case) */
|
||||
if( text->compiled ){
|
||||
Py_DECREF( (PyObject *)text->compiled );
|
||||
if(text->compiled){
|
||||
Py_DECREF((PyObject *)text->compiled);
|
||||
}
|
||||
|
||||
/* compile the buffer */
|
||||
buf = txt_to_buf( text );
|
||||
text->compiled = Py_CompileString( buf, text->id.name+2, Py_file_input );
|
||||
MEM_freeN( buf );
|
||||
buf= txt_to_buf(text);
|
||||
text->compiled= Py_CompileString(buf, text->id.name+2, Py_file_input);
|
||||
MEM_freeN(buf);
|
||||
|
||||
/* if compile failed.... return this error */
|
||||
if( PyErr_Occurred( ) ) {
|
||||
PyErr_Print( );
|
||||
PyErr_Clear( );
|
||||
if(PyErr_Occurred()) {
|
||||
PyErr_Print();
|
||||
PyErr_Clear();
|
||||
PySys_SetObject("last_traceback", NULL);
|
||||
free_compiled_text( text );
|
||||
free_compiled_text(text);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* make into a module */
|
||||
return PyImport_ExecCodeModule( (char *)name, text->compiled );
|
||||
return PyImport_ExecCodeModule((char *)name, text->compiled);
|
||||
}
|
||||
|
||||
|
||||
static PyObject *blender_import(PyObject *UNUSED(self), PyObject *args, PyObject * kw)
|
||||
static PyObject *blender_import(PyObject *UNUSED(self), PyObject *args, PyObject * kw)
|
||||
{
|
||||
PyObject *exception, *err, *tb;
|
||||
char *name;
|
||||
int found= 0;
|
||||
PyObject *globals = NULL, *locals = NULL, *fromlist = NULL;
|
||||
PyObject *globals= NULL, *locals= NULL, *fromlist= NULL;
|
||||
int level= -1; /* relative imports */
|
||||
|
||||
PyObject *newmodule;
|
||||
//PyObject_Print(args, stderr, 0);
|
||||
static const char *kwlist[] = {"name", "globals", "locals", "fromlist", "level", NULL};
|
||||
static const char *kwlist[]= {"name", "globals", "locals", "fromlist", "level", NULL};
|
||||
|
||||
if( !PyArg_ParseTupleAndKeywords(args, kw, "s|OOOi:bpy_import_meth", (char **)kwlist,
|
||||
&name, &globals, &locals, &fromlist, &level) )
|
||||
if(!PyArg_ParseTupleAndKeywords(args, kw, "s|OOOi:bpy_import_meth", (char **)kwlist,
|
||||
&name, &globals, &locals, &fromlist, &level))
|
||||
return NULL;
|
||||
|
||||
/* import existing builtin modules or modules that have been imported already */
|
||||
@ -222,28 +222,28 @@ static PyObject *blender_import(PyObject *UNUSED(self), PyObject *args, PyObjec
|
||||
if(newmodule)
|
||||
return newmodule;
|
||||
|
||||
PyErr_Fetch( &exception, &err, &tb ); /* get the python error incase we cant import as blender text either */
|
||||
PyErr_Fetch(&exception, &err, &tb); /* get the python error incase we cant import as blender text either */
|
||||
|
||||
/* importing from existing modules failed, see if we have this module as blender text */
|
||||
newmodule = bpy_text_import_name( name, &found );
|
||||
newmodule= bpy_text_import_name(name, &found);
|
||||
|
||||
if( newmodule ) {/* found module as blender text, ignore above exception */
|
||||
PyErr_Clear( );
|
||||
Py_XDECREF( exception );
|
||||
Py_XDECREF( err );
|
||||
Py_XDECREF( tb );
|
||||
/* printf( "imported from text buffer...\n" ); */
|
||||
if(newmodule) {/* found module as blender text, ignore above exception */
|
||||
PyErr_Clear();
|
||||
Py_XDECREF(exception);
|
||||
Py_XDECREF(err);
|
||||
Py_XDECREF(tb);
|
||||
/* printf("imported from text buffer...\n"); */
|
||||
}
|
||||
else if (found==1) { /* blender text module failed to execute but was found, use its error message */
|
||||
Py_XDECREF( exception );
|
||||
Py_XDECREF( err );
|
||||
Py_XDECREF( tb );
|
||||
Py_XDECREF(exception);
|
||||
Py_XDECREF(err);
|
||||
Py_XDECREF(tb);
|
||||
return NULL;
|
||||
}
|
||||
else {
|
||||
/* no blender text was found that could import the module
|
||||
* rause the original error from PyImport_ImportModuleEx */
|
||||
PyErr_Restore( exception, err, tb );
|
||||
PyErr_Restore(exception, err, tb);
|
||||
}
|
||||
return newmodule;
|
||||
}
|
||||
@ -256,42 +256,42 @@ static PyObject *blender_import(PyObject *UNUSED(self), PyObject *args, PyObjec
|
||||
static PyObject *blender_reload(PyObject *UNUSED(self), PyObject * module)
|
||||
{
|
||||
PyObject *exception, *err, *tb;
|
||||
PyObject *newmodule = NULL;
|
||||
PyObject *newmodule= NULL;
|
||||
int found= 0;
|
||||
|
||||
/* try reimporting from file */
|
||||
newmodule = PyImport_ReloadModule( module );
|
||||
if( newmodule )
|
||||
newmodule= PyImport_ReloadModule(module);
|
||||
if(newmodule)
|
||||
return newmodule;
|
||||
|
||||
/* no file, try importing from memory */
|
||||
PyErr_Fetch( &exception, &err, &tb ); /*restore for probable later use */
|
||||
PyErr_Fetch(&exception, &err, &tb); /*restore for probable later use */
|
||||
|
||||
newmodule = bpy_text_reimport( module, &found );
|
||||
if( newmodule ) {/* found module as blender text, ignore above exception */
|
||||
PyErr_Clear( );
|
||||
Py_XDECREF( exception );
|
||||
Py_XDECREF( err );
|
||||
Py_XDECREF( tb );
|
||||
/* printf( "imported from text buffer...\n" ); */
|
||||
newmodule= bpy_text_reimport(module, &found);
|
||||
if(newmodule) {/* found module as blender text, ignore above exception */
|
||||
PyErr_Clear();
|
||||
Py_XDECREF(exception);
|
||||
Py_XDECREF(err);
|
||||
Py_XDECREF(tb);
|
||||
/* printf("imported from text buffer...\n"); */
|
||||
}
|
||||
else if (found==1) { /* blender text module failed to execute but was found, use its error message */
|
||||
Py_XDECREF( exception );
|
||||
Py_XDECREF( err );
|
||||
Py_XDECREF( tb );
|
||||
Py_XDECREF(exception);
|
||||
Py_XDECREF(err);
|
||||
Py_XDECREF(tb);
|
||||
return NULL;
|
||||
}
|
||||
else {
|
||||
/* no blender text was found that could import the module
|
||||
* rause the original error from PyImport_ImportModuleEx */
|
||||
PyErr_Restore( exception, err, tb );
|
||||
PyErr_Restore(exception, err, tb);
|
||||
}
|
||||
|
||||
return newmodule;
|
||||
}
|
||||
|
||||
PyMethodDef bpy_import_meth = {"bpy_import_meth", (PyCFunction)blender_import, METH_VARARGS | METH_KEYWORDS, "blenders import"};
|
||||
PyMethodDef bpy_reload_meth = {"bpy_reload_meth", (PyCFunction)blender_reload, METH_O, "blenders reload"};
|
||||
PyMethodDef bpy_import_meth= {"bpy_import_meth", (PyCFunction)blender_import, METH_VARARGS | METH_KEYWORDS, "blenders import"};
|
||||
PyMethodDef bpy_reload_meth= {"bpy_reload_meth", (PyCFunction)blender_reload, METH_O, "blenders reload"};
|
||||
|
||||
|
||||
/* Clear user modules.
|
||||
@ -327,7 +327,7 @@ void bpy_text_clear_modules(int clear_all)
|
||||
|
||||
/* looping over the dict */
|
||||
PyObject *key, *value;
|
||||
int pos = 0;
|
||||
int pos= 0;
|
||||
|
||||
/* new list */
|
||||
PyObject *list;
|
||||
@ -344,7 +344,7 @@ void bpy_text_clear_modules(int clear_all)
|
||||
fname= PyModule_GetFilename(value);
|
||||
if(fname) {
|
||||
if (clear_all || ((strstr(fname, SEPSTR))==0)) { /* no path ? */
|
||||
file_extension = strstr(fname, ".py");
|
||||
file_extension= strstr(fname, ".py");
|
||||
if(file_extension && (*(file_extension + 3) == '\0' || *(file_extension + 4) == '\0')) { /* .py or pyc extension? */
|
||||
/* now we can be fairly sure its a python import from the blendfile */
|
||||
PyList_Append(list, key); /* free'd with the list */
|
||||
|
@ -315,28 +315,28 @@ PyMODINIT_FUNC BPyInit_mathutils(void)
|
||||
PyObject *submodule;
|
||||
PyObject *item;
|
||||
|
||||
if( PyType_Ready( &vector_Type ) < 0 )
|
||||
if(PyType_Ready(&vector_Type) < 0)
|
||||
return NULL;
|
||||
if( PyType_Ready( &matrix_Type ) < 0 )
|
||||
if(PyType_Ready(&matrix_Type) < 0)
|
||||
return NULL;
|
||||
if( PyType_Ready( &euler_Type ) < 0 )
|
||||
if(PyType_Ready(&euler_Type) < 0)
|
||||
return NULL;
|
||||
if( PyType_Ready( &quaternion_Type ) < 0 )
|
||||
if(PyType_Ready(&quaternion_Type) < 0)
|
||||
return NULL;
|
||||
if( PyType_Ready( &color_Type ) < 0 )
|
||||
if(PyType_Ready(&color_Type) < 0)
|
||||
return NULL;
|
||||
|
||||
submodule = PyModule_Create(&M_Mathutils_module_def);
|
||||
|
||||
/* each type has its own new() function */
|
||||
PyModule_AddObject( submodule, "Vector", (PyObject *)&vector_Type );
|
||||
PyModule_AddObject( submodule, "Matrix", (PyObject *)&matrix_Type );
|
||||
PyModule_AddObject( submodule, "Euler", (PyObject *)&euler_Type );
|
||||
PyModule_AddObject( submodule, "Quaternion", (PyObject *)&quaternion_Type );
|
||||
PyModule_AddObject( submodule, "Color", (PyObject *)&color_Type );
|
||||
PyModule_AddObject(submodule, "Vector", (PyObject *)&vector_Type);
|
||||
PyModule_AddObject(submodule, "Matrix", (PyObject *)&matrix_Type);
|
||||
PyModule_AddObject(submodule, "Euler", (PyObject *)&euler_Type);
|
||||
PyModule_AddObject(submodule, "Quaternion", (PyObject *)&quaternion_Type);
|
||||
PyModule_AddObject(submodule, "Color", (PyObject *)&color_Type);
|
||||
|
||||
/* submodule */
|
||||
PyModule_AddObject( submodule, "geometry", (item=BPyInit_mathutils_geometry()));
|
||||
PyModule_AddObject(submodule, "geometry", (item=BPyInit_mathutils_geometry()));
|
||||
/* XXX, python doesnt do imports with this usefully yet
|
||||
* 'from mathutils.geometry import PolyFill'
|
||||
* ...fails without this. */
|
||||
|
@ -243,7 +243,7 @@ static int Color_ass_slice(ColorObject * self, int begin, int end, PyObject * se
|
||||
CLAMP(begin, 0, COLOR_SIZE);
|
||||
if (end<0) end= (COLOR_SIZE + 1) + end;
|
||||
CLAMP(end, 0, COLOR_SIZE);
|
||||
begin = MIN2(begin,end);
|
||||
begin = MIN2(begin, end);
|
||||
|
||||
if((size=mathutils_array_parse(col, 0, COLOR_SIZE, seq, "mathutils.Color[begin:end] = []")) == -1)
|
||||
return -1;
|
||||
@ -270,7 +270,8 @@ static PyObject *Color_subscript(ColorObject *self, PyObject *item)
|
||||
if (i < 0)
|
||||
i += COLOR_SIZE;
|
||||
return Color_item(self, i);
|
||||
} else if (PySlice_Check(item)) {
|
||||
}
|
||||
else if (PySlice_Check(item)) {
|
||||
Py_ssize_t start, stop, step, slicelength;
|
||||
|
||||
if (PySlice_GetIndicesEx((void *)item, COLOR_SIZE, &start, &stop, &step, &slicelength) < 0)
|
||||
@ -343,7 +344,7 @@ static PyMappingMethods Color_AsMapping = {
|
||||
};
|
||||
|
||||
/* color channel, vector.r/g/b */
|
||||
static PyObject *Color_getChannel( ColorObject * self, void *type )
|
||||
static PyObject *Color_getChannel(ColorObject * self, void *type)
|
||||
{
|
||||
return Color_item(self, GET_INT_FROM_POINTER(type));
|
||||
}
|
||||
@ -354,7 +355,7 @@ static int Color_setChannel(ColorObject * self, PyObject * value, void * type)
|
||||
}
|
||||
|
||||
/* color channel (HSV), color.h/s/v */
|
||||
static PyObject *Color_getChannelHSV( ColorObject * self, void *type )
|
||||
static PyObject *Color_getChannelHSV(ColorObject * self, void *type)
|
||||
{
|
||||
float hsv[3];
|
||||
int i= GET_INT_FROM_POINTER(type);
|
||||
@ -445,7 +446,7 @@ static PyGetSetDef Color_getseters[] = {
|
||||
|
||||
{(char *)"is_wrapped", (getter)BaseMathObject_getWrapped, (setter)NULL, BaseMathObject_Wrapped_doc, NULL},
|
||||
{(char *)"owner", (getter)BaseMathObject_getOwner, (setter)NULL, BaseMathObject_Owner_doc, NULL},
|
||||
{NULL,NULL,NULL,NULL,NULL} /* Sentinel */
|
||||
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
|
||||
};
|
||||
|
||||
|
||||
|
@ -199,7 +199,7 @@ static PyObject *Euler_rotate_axis(EulerObject * self, PyObject *args)
|
||||
const char *axis;
|
||||
|
||||
if(!PyArg_ParseTuple(args, "sf:rotate", &axis, &angle)){
|
||||
PyErr_SetString(PyExc_TypeError, "euler.rotate(): expected angle (float) and axis (x,y,z)");
|
||||
PyErr_SetString(PyExc_TypeError, "euler.rotate(): expected angle (float) and axis (x, y, z)");
|
||||
return NULL;
|
||||
}
|
||||
if(!(ELEM3(*axis, 'X', 'Y', 'Z') && axis[1]=='\0')){
|
||||
@ -428,7 +428,7 @@ static int Euler_ass_slice(EulerObject * self, int begin, int end, PyObject * se
|
||||
CLAMP(begin, 0, EULER_SIZE);
|
||||
if (end<0) end= (EULER_SIZE + 1) + end;
|
||||
CLAMP(end, 0, EULER_SIZE);
|
||||
begin = MIN2(begin,end);
|
||||
begin = MIN2(begin, end);
|
||||
|
||||
if((size=mathutils_array_parse(eul, 0, EULER_SIZE, seq, "mathutils.Euler[begin:end] = []")) == -1)
|
||||
return -1;
|
||||
@ -455,7 +455,8 @@ static PyObject *Euler_subscript(EulerObject *self, PyObject *item)
|
||||
if (i < 0)
|
||||
i += EULER_SIZE;
|
||||
return Euler_item(self, i);
|
||||
} else if (PySlice_Check(item)) {
|
||||
}
|
||||
else if (PySlice_Check(item)) {
|
||||
Py_ssize_t start, stop, step, slicelength;
|
||||
|
||||
if (PySlice_GetIndicesEx((void *)item, EULER_SIZE, &start, &stop, &step, &slicelength) < 0)
|
||||
@ -531,7 +532,7 @@ static PyMappingMethods Euler_AsMapping = {
|
||||
/*
|
||||
* euler axis, euler.x/y/z
|
||||
*/
|
||||
static PyObject *Euler_getAxis(EulerObject *self, void *type )
|
||||
static PyObject *Euler_getAxis(EulerObject *self, void *type)
|
||||
{
|
||||
return Euler_item(self, GET_INT_FROM_POINTER(type));
|
||||
}
|
||||
@ -574,7 +575,7 @@ static PyGetSetDef Euler_getseters[] = {
|
||||
|
||||
{(char *)"is_wrapped", (getter)BaseMathObject_getWrapped, (setter)NULL, (char *)BaseMathObject_Wrapped_doc, NULL},
|
||||
{(char *)"owner", (getter)BaseMathObject_getOwner, (setter)NULL, (char *)BaseMathObject_Owner_doc, NULL},
|
||||
{NULL,NULL,NULL,NULL,NULL} /* Sentinel */
|
||||
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
|
||||
};
|
||||
|
||||
|
||||
|
@ -114,7 +114,7 @@ Mathutils_Callback mathutils_matrix_vector_cb = {
|
||||
/* matrix vector callbacks, this is so you can do matrix[i][j] = val */
|
||||
|
||||
//----------------------------------mathutils.Matrix() -----------------
|
||||
//mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
|
||||
//mat is a 1D array of floats - row[0][0], row[0][1], row[1][0], etc.
|
||||
//create a new matrix type
|
||||
static PyObject *Matrix_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
||||
{
|
||||
@ -185,7 +185,7 @@ static void matrix_3x3_as_4x4(float mat[16])
|
||||
|
||||
/*-----------------------CLASS-METHODS----------------------------*/
|
||||
|
||||
//mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
|
||||
//mat is a 1D array of floats - row[0][0], row[0][1], row[1][0], etc.
|
||||
static char C_Matrix_Rotation_doc[] =
|
||||
".. classmethod:: Rotation(angle, size, axis)\n"
|
||||
"\n"
|
||||
@ -257,21 +257,24 @@ static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args)
|
||||
mat[1] = (float) sin (angle);
|
||||
mat[2] = -((float) sin(angle));
|
||||
mat[3] = (float) cos(angle);
|
||||
} else if(strcmp(axis, "X") == 0) {
|
||||
}
|
||||
else if(strcmp(axis, "X") == 0) {
|
||||
//rotation around X
|
||||
mat[0] = 1.0f;
|
||||
mat[4] = (float) cos(angle);
|
||||
mat[5] = (float) sin(angle);
|
||||
mat[7] = -((float) sin(angle));
|
||||
mat[8] = (float) cos(angle);
|
||||
} else if(strcmp(axis, "Y") == 0) {
|
||||
}
|
||||
else if(strcmp(axis, "Y") == 0) {
|
||||
//rotation around Y
|
||||
mat[0] = (float) cos(angle);
|
||||
mat[2] = -((float) sin(angle));
|
||||
mat[4] = 1.0f;
|
||||
mat[6] = (float) sin(angle);
|
||||
mat[8] = (float) cos(angle);
|
||||
} else if(strcmp(axis, "Z") == 0) {
|
||||
}
|
||||
else if(strcmp(axis, "Z") == 0) {
|
||||
//rotation around Z
|
||||
mat[0] = (float) cos(angle);
|
||||
mat[1] = (float) sin(angle);
|
||||
@ -316,7 +319,7 @@ static PyObject *C_Matrix_Translation(PyObject *cls, PyObject *value)
|
||||
return newMatrixObject(mat, 4, 4, Py_NEW, (PyTypeObject *)cls);
|
||||
}
|
||||
//----------------------------------mathutils.Matrix.Scale() -------------
|
||||
//mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
|
||||
//mat is a 1D array of floats - row[0][0], row[0][1], row[1][0], etc.
|
||||
static char C_Matrix_Scale_doc[] =
|
||||
".. classmethod:: Scale(factor, size, axis)\n"
|
||||
"\n"
|
||||
@ -399,7 +402,7 @@ static PyObject *C_Matrix_Scale(PyObject *cls, PyObject *args)
|
||||
return newMatrixObject(mat, matSize, matSize, Py_NEW, (PyTypeObject *)cls);
|
||||
}
|
||||
//----------------------------------mathutils.Matrix.OrthoProjection() ---
|
||||
//mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
|
||||
//mat is a 1D array of floats - row[0][0], row[0][1], row[1][0], etc.
|
||||
static char C_Matrix_OrthoProjection_doc[] =
|
||||
".. classmethod:: OrthoProjection(axis, size)\n"
|
||||
"\n"
|
||||
@ -610,7 +613,8 @@ static float matrix_determinant_internal(MatrixObject *self)
|
||||
if(self->row_size == 2) {
|
||||
return determinant_m2(self->matrix[0][0], self->matrix[0][1],
|
||||
self->matrix[1][0], self->matrix[1][1]);
|
||||
} else if(self->row_size == 3) {
|
||||
}
|
||||
else if(self->row_size == 3) {
|
||||
return determinant_m3(self->matrix[0][0], self->matrix[0][1],
|
||||
self->matrix[0][2], self->matrix[1][0],
|
||||
self->matrix[1][1], self->matrix[1][2],
|
||||
@ -644,9 +648,10 @@ static PyObject *Matrix_to_quaternion(MatrixObject *self)
|
||||
return NULL;
|
||||
}
|
||||
if(self->col_size == 3){
|
||||
mat3_to_quat( quat,(float (*)[3])self->contigPtr);
|
||||
}else{
|
||||
mat4_to_quat( quat,(float (*)[4])self->contigPtr);
|
||||
mat3_to_quat(quat, (float (*)[3])self->contigPtr);
|
||||
}
|
||||
else {
|
||||
mat4_to_quat(quat, (float (*)[4])self->contigPtr);
|
||||
}
|
||||
|
||||
return newQuaternionObject(quat, Py_NEW, NULL);
|
||||
@ -691,10 +696,12 @@ static PyObject *Matrix_to_euler(MatrixObject *self, PyObject *args)
|
||||
/*must be 3-4 cols, 3-4 rows, square matrix*/
|
||||
if(self->col_size ==3 && self->row_size ==3) {
|
||||
mat= (float (*)[3])self->contigPtr;
|
||||
}else if (self->col_size ==4 && self->row_size ==4) {
|
||||
}
|
||||
else if (self->col_size ==4 && self->row_size ==4) {
|
||||
copy_m3_m4(tmat, (float (*)[4])self->contigPtr);
|
||||
mat= tmat;
|
||||
}else {
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_AttributeError, "Matrix.to_euler(): inappropriate matrix size - expects 3x3 or 4x4 matrix");
|
||||
return NULL;
|
||||
}
|
||||
@ -707,7 +714,7 @@ static PyObject *Matrix_to_euler(MatrixObject *self, PyObject *args)
|
||||
}
|
||||
|
||||
if(eul_compat) {
|
||||
if(order == 1) mat3_to_compatible_eul( eul, eul_compatf, mat);
|
||||
if(order == 1) mat3_to_compatible_eul(eul, eul_compatf, mat);
|
||||
else mat3_to_compatible_eulO(eul, eul_compatf, order, mat);
|
||||
}
|
||||
else {
|
||||
@ -751,7 +758,8 @@ static PyObject *Matrix_resize_4x4(MatrixObject *self)
|
||||
index = (4 * (self->row_size + (blank_rows - 1))) + x;
|
||||
if (index == 10 || index == 15){
|
||||
self->contigPtr[index] = 1.0f;
|
||||
}else{
|
||||
}
|
||||
else {
|
||||
self->contigPtr[index] = 0.0f;
|
||||
}
|
||||
}
|
||||
@ -759,7 +767,7 @@ static PyObject *Matrix_resize_4x4(MatrixObject *self)
|
||||
for(x = 1; x <= self->row_size; x++){
|
||||
first_row_elem = (self->col_size * (self->row_size - x));
|
||||
curr_pos = (first_row_elem + (self->col_size -1));
|
||||
new_pos = (4 * (self->row_size - x )) + (curr_pos - first_row_elem);
|
||||
new_pos = (4 * (self->row_size - x)) + (curr_pos - first_row_elem);
|
||||
for(blank_columns = (4 - self->col_size); blank_columns > 0; blank_columns--){
|
||||
self->contigPtr[new_pos + blank_columns] = 0.0f;
|
||||
}
|
||||
@ -1346,7 +1354,7 @@ static PyObject *Matrix_slice(MatrixObject *self, int begin, int end)
|
||||
|
||||
CLAMP(begin, 0, self->row_size);
|
||||
CLAMP(end, 0, self->row_size);
|
||||
begin= MIN2(begin,end);
|
||||
begin= MIN2(begin, end);
|
||||
|
||||
tuple= PyTuple_New(end - begin);
|
||||
for(count= begin; count < end; count++) {
|
||||
@ -1368,7 +1376,7 @@ static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *va
|
||||
|
||||
CLAMP(begin, 0, self->row_size);
|
||||
CLAMP(end, 0, self->row_size);
|
||||
begin = MIN2(begin,end);
|
||||
begin = MIN2(begin, end);
|
||||
|
||||
/* non list/tuple cases */
|
||||
if(!(value_fast=PySequence_Fast(value, "matrix[begin:end] = value"))) {
|
||||
@ -1712,7 +1720,7 @@ static PyGetSetDef Matrix_getseters[] = {
|
||||
{(char *)"is_negative", (getter)Matrix_getIsNegative, (setter)NULL, (char *)"True if this matrix results in a negative scale, 3x3 and 4x4 only, (readonly).\n\n:type: bool", NULL},
|
||||
{(char *)"is_wrapped", (getter)BaseMathObject_getWrapped, (setter)NULL, (char *)BaseMathObject_Wrapped_doc, NULL},
|
||||
{(char *)"owner",(getter)BaseMathObject_getOwner, (setter)NULL, (char *)BaseMathObject_Owner_doc, NULL},
|
||||
{NULL,NULL,NULL,NULL,NULL} /* Sentinel */
|
||||
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
|
||||
};
|
||||
|
||||
/*-----------------------METHOD DEFINITIONS ----------------------*/
|
||||
@ -1873,7 +1881,7 @@ PyObject *newMatrixObject(float *mat, const unsigned short rowSize, const unsign
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (rowSize == colSize ) { /*or if no arguments are passed return identity matrix for square matrices */
|
||||
else if (rowSize == colSize) { /*or if no arguments are passed return identity matrix for square matrices */
|
||||
PyObject *ret_dummy= Matrix_identity(self);
|
||||
Py_DECREF(ret_dummy);
|
||||
}
|
||||
|
@ -136,7 +136,7 @@ static PyObject *Quaternion_to_matrix(QuaternionObject *self)
|
||||
if(BaseMath_ReadCallback(self) == -1)
|
||||
return NULL;
|
||||
|
||||
quat_to_mat3( (float (*)[3]) mat,self->quat);
|
||||
quat_to_mat3((float (*)[3])mat, self->quat);
|
||||
return newMatrixObject(mat, 3, 3, Py_NEW, NULL);
|
||||
}
|
||||
|
||||
@ -283,7 +283,7 @@ static PyObject *Quaternion_rotate(QuaternionObject *self, PyObject *value)
|
||||
}
|
||||
|
||||
//----------------------------Quaternion.normalize()----------------
|
||||
//normalize the axis of rotation of [theta,vector]
|
||||
//normalize the axis of rotation of [theta, vector]
|
||||
static char Quaternion_normalize_doc[] =
|
||||
".. function:: normalize()\n"
|
||||
"\n"
|
||||
@ -562,7 +562,7 @@ static int Quaternion_ass_slice(QuaternionObject *self, int begin, int end, PyOb
|
||||
CLAMP(begin, 0, QUAT_SIZE);
|
||||
if (end<0) end= (QUAT_SIZE + 1) + end;
|
||||
CLAMP(end, 0, QUAT_SIZE);
|
||||
begin = MIN2(begin,end);
|
||||
begin = MIN2(begin, end);
|
||||
|
||||
if((size=mathutils_array_parse(quat, 0, QUAT_SIZE, seq, "mathutils.Quaternion[begin:end] = []")) == -1)
|
||||
return -1;
|
||||
@ -721,7 +721,7 @@ static PyObject *Quaternion_mul(PyObject *q1, PyObject *q2)
|
||||
mul_qt_qtqt(quat, quat1->quat, quat2->quat);
|
||||
return newQuaternionObject(quat, Py_NEW, Py_TYPE(q1));
|
||||
}
|
||||
/* the only case this can happen (for a supported type is "FLOAT*QUAT" ) */
|
||||
/* the only case this can happen (for a supported type is "FLOAT*QUAT") */
|
||||
else if(quat2) { /* FLOAT*QUAT */
|
||||
if(((scalar= PyFloat_AsDouble(q1)) == -1.0 && PyErr_Occurred())==0) {
|
||||
return quat_mul_float(quat2, scalar);
|
||||
@ -811,12 +811,12 @@ static PyNumberMethods Quaternion_NumMethods = {
|
||||
NULL, /* nb_index */
|
||||
};
|
||||
|
||||
static PyObject *Quaternion_getAxis( QuaternionObject *self, void *type )
|
||||
static PyObject *Quaternion_getAxis(QuaternionObject *self, void *type)
|
||||
{
|
||||
return Quaternion_item(self, GET_INT_FROM_POINTER(type));
|
||||
}
|
||||
|
||||
static int Quaternion_setAxis( QuaternionObject *self, PyObject *value, void *type )
|
||||
static int Quaternion_setAxis(QuaternionObject *self, PyObject *value, void *type)
|
||||
{
|
||||
return Quaternion_ass_item(self, GET_INT_FROM_POINTER(type), value);
|
||||
}
|
||||
@ -864,7 +864,7 @@ static int Quaternion_setAngle(QuaternionObject *self, PyObject *value, void *UN
|
||||
angle= fmod(angle + M_PI*2, M_PI*4) - M_PI*2;
|
||||
|
||||
/* If the axis of rotation is 0,0,0 set it to 1,0,0 - for zero-degree rotations */
|
||||
if( EXPP_FloatsAreEqual(axis[0], 0.0f, 10) &&
|
||||
if( EXPP_FloatsAreEqual(axis[0], 0.0f, 10) &&
|
||||
EXPP_FloatsAreEqual(axis[1], 0.0f, 10) &&
|
||||
EXPP_FloatsAreEqual(axis[2], 0.0f, 10)
|
||||
) {
|
||||
@ -894,7 +894,7 @@ static PyObject *Quaternion_getAxisVec(QuaternionObject *self, void *UNUSED(clos
|
||||
quat_to_axis_angle(axis, &angle, tquat);
|
||||
|
||||
/* If the axis of rotation is 0,0,0 set it to 1,0,0 - for zero-degree rotations */
|
||||
if( EXPP_FloatsAreEqual(axis[0], 0.0f, 10) &&
|
||||
if( EXPP_FloatsAreEqual(axis[0], 0.0f, 10) &&
|
||||
EXPP_FloatsAreEqual(axis[1], 0.0f, 10) &&
|
||||
EXPP_FloatsAreEqual(axis[2], 0.0f, 10)
|
||||
) {
|
||||
@ -1022,7 +1022,7 @@ static PyGetSetDef Quaternion_getseters[] = {
|
||||
{(char *)"axis",(getter)Quaternion_getAxisVec, (setter)Quaternion_setAxisVec, (char *)"quaternion axis as a vector.\n\n:type: :class:`Vector`", NULL},
|
||||
{(char *)"is_wrapped", (getter)BaseMathObject_getWrapped, (setter)NULL, (char *)BaseMathObject_Wrapped_doc, NULL},
|
||||
{(char *)"owner", (getter)BaseMathObject_getOwner, (setter)NULL, (char *)BaseMathObject_Owner_doc, NULL},
|
||||
{NULL,NULL,NULL,NULL,NULL} /* Sentinel */
|
||||
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
|
||||
};
|
||||
|
||||
//------------------PY_OBECT DEFINITION--------------------------
|
||||
@ -1103,12 +1103,13 @@ PyObject *newQuaternionObject(float *quat, int type, PyTypeObject *base_type)
|
||||
self->quat = PyMem_Malloc(QUAT_SIZE * sizeof(float));
|
||||
if(!quat) { //new empty
|
||||
unit_qt(self->quat);
|
||||
}else{
|
||||
}
|
||||
else {
|
||||
QUATCOPY(self->quat, quat);
|
||||
}
|
||||
self->wrapped = Py_NEW;
|
||||
}
|
||||
else{
|
||||
else {
|
||||
PyErr_SetString(PyExc_RuntimeError, "Quaternion(): invalid type");
|
||||
return NULL;
|
||||
}
|
||||
|
@ -228,10 +228,12 @@ static PyObject *Vector_resize_4d(VectorObject *self)
|
||||
PyErr_SetString(PyExc_MemoryError, "vector.resize_4d(): problem allocating pointer space");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if(self->size == 2){
|
||||
self->vec[2] = 0.0f;
|
||||
self->vec[3] = 1.0f;
|
||||
}else if(self->size == 3){
|
||||
}
|
||||
else if(self->size == 3){
|
||||
self->vec[3] = 1.0f;
|
||||
}
|
||||
self->size = 4;
|
||||
@ -354,13 +356,13 @@ static char Vector_to_track_quat_doc[] =
|
||||
" :return: rotation from the vector and the track and up axis.\n"
|
||||
" :rtype: :class:`Quaternion`\n"
|
||||
;
|
||||
static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args )
|
||||
static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args)
|
||||
{
|
||||
float vec[3], quat[4];
|
||||
const char *strack, *sup;
|
||||
short track = 2, up = 1;
|
||||
|
||||
if(!PyArg_ParseTuple( args, "|ss:to_track_quat", &strack, &sup))
|
||||
if(!PyArg_ParseTuple(args, "|ss:to_track_quat", &strack, &sup))
|
||||
return NULL;
|
||||
|
||||
if (self->size != 3) {
|
||||
@ -451,7 +453,7 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args )
|
||||
*/
|
||||
negate_v3_v3(vec, self->vec);
|
||||
|
||||
vec_to_quat( quat,vec, track, up);
|
||||
vec_to_quat(quat, vec, track, up);
|
||||
|
||||
return newQuaternionObject(quat, Py_NEW, NULL);
|
||||
}
|
||||
@ -873,7 +875,7 @@ static int Vector_ass_slice(VectorObject *self, int begin, int end,
|
||||
|
||||
CLAMP(begin, 0, self->size);
|
||||
CLAMP(end, 0, self->size);
|
||||
begin = MIN2(begin,end);
|
||||
begin = MIN2(begin, end);
|
||||
|
||||
size = (end - begin);
|
||||
if(mathutils_array_parse(vec, size, size, seq, "vector[begin:end] = [...]") == -1)
|
||||
@ -1066,7 +1068,7 @@ static PyObject *Vector_mul(PyObject * v1, PyObject * v2)
|
||||
|
||||
|
||||
/* make sure v1 is always the vector */
|
||||
if (vec1 && vec2 ) {
|
||||
if (vec1 && vec2) {
|
||||
int i;
|
||||
double dot = 0.0f;
|
||||
|
||||
@ -1170,7 +1172,7 @@ static PyObject *Vector_imul(PyObject * v1, PyObject * v2)
|
||||
}
|
||||
|
||||
(void)BaseMath_WriteCallback(vec);
|
||||
Py_INCREF( v1 );
|
||||
Py_INCREF(v1);
|
||||
return v1;
|
||||
}
|
||||
|
||||
@ -1231,7 +1233,7 @@ static PyObject *Vector_idiv(PyObject * v1, PyObject * v2)
|
||||
|
||||
(void)BaseMath_WriteCallback(vec1);
|
||||
|
||||
Py_INCREF( v1 );
|
||||
Py_INCREF(v1);
|
||||
return v1;
|
||||
}
|
||||
|
||||
@ -1272,12 +1274,13 @@ static PyObject* Vector_richcmpr(PyObject *objectA, PyObject *objectB, int compa
|
||||
VectorObject *vecA = NULL, *vecB = NULL;
|
||||
int result = 0;
|
||||
float epsilon = .000001f;
|
||||
double lenA,lenB;
|
||||
double lenA, lenB;
|
||||
|
||||
if (!VectorObject_Check(objectA) || !VectorObject_Check(objectB)){
|
||||
if (comparison_type == Py_NE){
|
||||
Py_RETURN_TRUE;
|
||||
}else{
|
||||
}
|
||||
else {
|
||||
Py_RETURN_FALSE;
|
||||
}
|
||||
}
|
||||
@ -1290,7 +1293,8 @@ static PyObject* Vector_richcmpr(PyObject *objectA, PyObject *objectB, int compa
|
||||
if (vecA->size != vecB->size){
|
||||
if (comparison_type == Py_NE){
|
||||
Py_RETURN_TRUE;
|
||||
}else{
|
||||
}
|
||||
else {
|
||||
Py_RETURN_FALSE;
|
||||
}
|
||||
}
|
||||
@ -1299,16 +1303,17 @@ static PyObject* Vector_richcmpr(PyObject *objectA, PyObject *objectB, int compa
|
||||
case Py_LT:
|
||||
lenA = vec_magnitude_nosqrt(vecA->vec, vecA->size);
|
||||
lenB = vec_magnitude_nosqrt(vecB->vec, vecB->size);
|
||||
if( lenA < lenB ){
|
||||
if(lenA < lenB){
|
||||
result = 1;
|
||||
}
|
||||
break;
|
||||
case Py_LE:
|
||||
lenA = vec_magnitude_nosqrt(vecA->vec, vecA->size);
|
||||
lenB = vec_magnitude_nosqrt(vecB->vec, vecB->size);
|
||||
if( lenA < lenB ){
|
||||
if(lenA < lenB){
|
||||
result = 1;
|
||||
}else{
|
||||
}
|
||||
else {
|
||||
result = (((lenA + epsilon) > lenB) && ((lenA - epsilon) < lenB));
|
||||
}
|
||||
break;
|
||||
@ -1321,16 +1326,17 @@ static PyObject* Vector_richcmpr(PyObject *objectA, PyObject *objectB, int compa
|
||||
case Py_GT:
|
||||
lenA = vec_magnitude_nosqrt(vecA->vec, vecA->size);
|
||||
lenB = vec_magnitude_nosqrt(vecB->vec, vecB->size);
|
||||
if( lenA > lenB ){
|
||||
if(lenA > lenB){
|
||||
result = 1;
|
||||
}
|
||||
break;
|
||||
case Py_GE:
|
||||
lenA = vec_magnitude_nosqrt(vecA->vec, vecA->size);
|
||||
lenB = vec_magnitude_nosqrt(vecB->vec, vecB->size);
|
||||
if( lenA > lenB ){
|
||||
if(lenA > lenB){
|
||||
result = 1;
|
||||
}else{
|
||||
}
|
||||
else {
|
||||
result = (((lenA + epsilon) > lenB) && ((lenA - epsilon) < lenB));
|
||||
}
|
||||
break;
|
||||
@ -1340,7 +1346,8 @@ static PyObject* Vector_richcmpr(PyObject *objectA, PyObject *objectB, int compa
|
||||
}
|
||||
if (result == 1){
|
||||
Py_RETURN_TRUE;
|
||||
}else{
|
||||
}
|
||||
else {
|
||||
Py_RETURN_FALSE;
|
||||
}
|
||||
}
|
||||
@ -1369,7 +1376,8 @@ static PyObject *Vector_subscript(VectorObject* self, PyObject* item)
|
||||
if (i < 0)
|
||||
i += self->size;
|
||||
return Vector_item(self, i);
|
||||
} else if (PySlice_Check(item)) {
|
||||
}
|
||||
else if (PySlice_Check(item)) {
|
||||
Py_ssize_t start, stop, step, slicelength;
|
||||
|
||||
if (PySlice_GetIndicesEx((void *)item, self->size, &start, &stop, &step, &slicelength) < 0)
|
||||
@ -2001,7 +2009,7 @@ static PyGetSetDef Vector_getseters[] = {
|
||||
{(char *)"wwwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3))) )}, // 3071
|
||||
{(char *)"wwwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3))) )}, // 3583
|
||||
{(char *)"wwww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3))) )}, // 4095
|
||||
{NULL,NULL,NULL,NULL,NULL} /* Sentinel */
|
||||
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
|
||||
};
|
||||
|
||||
/* Python script used to make swizzle array */
|
||||
@ -2061,7 +2069,8 @@ static int row_vector_multiplication(float rvec[4], VectorObject* vec, MatrixObj
|
||||
if(mat->colSize == 4 && vec_size != 3){
|
||||
PyErr_SetString(PyExc_AttributeError, "vector * matrix: matrix column size and the vector size must be the same");
|
||||
return -1;
|
||||
}else{
|
||||
}
|
||||
else {
|
||||
vec_cpy[3] = 1.0f;
|
||||
}
|
||||
}
|
||||
@ -2156,12 +2165,12 @@ PyTypeObject vector_Type = {
|
||||
|
||||
/* Methods to implement standard operations */
|
||||
|
||||
( destructor ) BaseMathObject_dealloc,/* destructor tp_dealloc; */
|
||||
(destructor) BaseMathObject_dealloc,/* destructor tp_dealloc; */
|
||||
NULL, /* printfunc tp_print; */
|
||||
NULL, /* getattrfunc tp_getattr; */
|
||||
NULL, /* setattrfunc tp_setattr; */
|
||||
NULL, /* cmpfunc tp_compare; */
|
||||
( reprfunc ) Vector_repr, /* reprfunc tp_repr; */
|
||||
(reprfunc)Vector_repr, /* reprfunc tp_repr; */
|
||||
|
||||
/* Method suites for standard classes */
|
||||
|
||||
|
@ -48,7 +48,7 @@
|
||||
|
||||
#include "BKE_curve.h"
|
||||
|
||||
#define SWAP_FLOAT(a,b,tmp) tmp=a; a=b; b=tmp
|
||||
#define SWAP_FLOAT(a, b, tmp) tmp=a; a=b; b=tmp
|
||||
#define eps 0.000001
|
||||
|
||||
|
||||
@ -446,7 +446,8 @@ static PyObject *M_Geometry_tesselate_polygon(PyObject *UNUSED(self), PyObject *
|
||||
index++;
|
||||
}
|
||||
freedisplist(&dispbase);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
/* no points, do this so scripts dont barf */
|
||||
freedisplist(&dispbase); /* possible some dl was allocated */
|
||||
tri_list= PyList_New(0);
|
||||
@ -489,7 +490,8 @@ static PyObject *M_Geometry_intersect_line_line_2d(PyObject *UNUSED(self), PyObj
|
||||
|
||||
if(isect_seg_seg_v2_point(line_a1->vec, line_a2->vec, line_b1->vec, line_b2->vec, vi) == 1) {
|
||||
return newVectorObject(vi, 2, Py_NEW, NULL);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
}
|
||||
@ -537,7 +539,7 @@ static PyObject *M_Geometry_intersect_point_line(PyObject *UNUSED(self), PyObjec
|
||||
else { l2[2]=0.0; VECCOPY2D(l2, line_2->vec) }
|
||||
|
||||
/* do the calculation */
|
||||
lambda= closest_to_line_v3(pt_out,pt_in, l1, l2);
|
||||
lambda= closest_to_line_v3(pt_out, pt_in, l1, l2);
|
||||
|
||||
ret= PyTuple_New(2);
|
||||
PyTuple_SET_ITEM(ret, 0, newVectorObject(pt_out, 3, Py_NEW, NULL));
|
||||
@ -684,7 +686,7 @@ static char M_Geometry_box_pack_2d_doc[] =
|
||||
"\n"
|
||||
" Returns the normal of the 3D tri or quad.\n"
|
||||
"\n"
|
||||
" :arg boxes: list of boxes, each box is a list where the first 4 items are [x,y, width, height, ...] other items are ignored.\n"
|
||||
" :arg boxes: list of boxes, each box is a list where the first 4 items are [x, y, width, height, ...] other items are ignored.\n"
|
||||
" :type boxes: list\n"
|
||||
" :return: the width and height of the packed bounding box\n"
|
||||
" :rtype: tuple, pair of floats\n"
|
||||
@ -697,7 +699,7 @@ static PyObject *M_Geometry_box_pack_2d(PyObject *UNUSED(self), PyObject *boxlis
|
||||
PyObject *ret;
|
||||
|
||||
if(!PyList_Check(boxlist)) {
|
||||
PyErr_SetString(PyExc_TypeError, "expected a list of boxes [[x,y,w,h], ... ]");
|
||||
PyErr_SetString(PyExc_TypeError, "expected a list of boxes [[x, y, w, h], ... ]");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -212,8 +212,10 @@ static void randuvec(float v[3])
|
||||
r = (float)sqrt(r);
|
||||
v[0] = (float)(r * cos(a));
|
||||
v[1] = (float)(r * sin(a));
|
||||
} else
|
||||
}
|
||||
else {
|
||||
v[2] = 1.f;
|
||||
}
|
||||
}
|
||||
|
||||
static PyObject *Noise_random(PyObject *UNUSED(self))
|
||||
|
@ -150,9 +150,11 @@ PyObject *PyC_ExceptionBuffer(void)
|
||||
|
||||
if(! (string_io_mod= PyImport_ImportModule("io")) ) {
|
||||
goto error_cleanup;
|
||||
} else if (! (string_io = PyObject_CallMethod(string_io_mod, (char *)"StringIO", NULL))) {
|
||||
}
|
||||
else if (! (string_io = PyObject_CallMethod(string_io_mod, (char *)"StringIO", NULL))) {
|
||||
goto error_cleanup;
|
||||
} else if (! (string_io_getvalue= PyObject_GetAttrString(string_io, "getvalue"))) {
|
||||
}
|
||||
else if (! (string_io_getvalue= PyObject_GetAttrString(string_io, "getvalue"))) {
|
||||
goto error_cleanup;
|
||||
}
|
||||
|
||||
|
@ -100,8 +100,8 @@ static PyObject *bpy_blend_paths(PyObject *UNUSED(self), PyObject *args, PyObjec
|
||||
char filepath_expanded[1024];
|
||||
const char *lib;
|
||||
|
||||
int absolute = 0;
|
||||
static const char *kwlist[] = {"absolute", NULL};
|
||||
int absolute= 0;
|
||||
static const char *kwlist[]= {"absolute", NULL};
|
||||
|
||||
if (!PyArg_ParseTupleAndKeywords(args, kw, "|i:blend_paths", (char **)kwlist, &absolute))
|
||||
return NULL;
|
||||
@ -114,7 +114,7 @@ static PyObject *bpy_blend_paths(PyObject *UNUSED(self), PyObject *args, PyObjec
|
||||
BLI_bpathIterator_getPathExpanded(bpi, filepath_expanded);
|
||||
}
|
||||
else {
|
||||
lib = BLI_bpathIterator_getLib(bpi);
|
||||
lib= BLI_bpathIterator_getLib(bpi);
|
||||
if (lib && (strcmp(lib, BLI_bpathIterator_getBasePath(bpi)))) { /* relative path to the library is NOT the same as our blendfile path, return an absolute path */
|
||||
BLI_bpathIterator_getPathExpanded(bpi, filepath_expanded);
|
||||
}
|
||||
@ -134,13 +134,13 @@ static PyObject *bpy_blend_paths(PyObject *UNUSED(self), PyObject *args, PyObjec
|
||||
}
|
||||
|
||||
|
||||
// static char bpy_user_resource_doc[] = // now in bpy/utils.py
|
||||
// static char bpy_user_resource_doc[]= // now in bpy/utils.py
|
||||
static PyObject *bpy_user_resource(PyObject *UNUSED(self), PyObject *args, PyObject *kw)
|
||||
{
|
||||
char *type;
|
||||
char *subdir= NULL;
|
||||
int folder_id;
|
||||
static const char *kwlist[] = {"type", "subdir", NULL};
|
||||
static const char *kwlist[]= {"type", "subdir", NULL};
|
||||
|
||||
char *path;
|
||||
|
||||
@ -161,14 +161,14 @@ static PyObject *bpy_user_resource(PyObject *UNUSED(self), PyObject *args, PyObj
|
||||
path= BLI_get_folder(folder_id, subdir);
|
||||
|
||||
if (!path)
|
||||
path = BLI_get_user_folder_notest(folder_id, subdir);
|
||||
path= BLI_get_user_folder_notest(folder_id, subdir);
|
||||
|
||||
return PyUnicode_DecodeFSDefault(path ? path : "");
|
||||
}
|
||||
|
||||
static PyMethodDef meth_bpy_script_paths = {"script_paths", (PyCFunction)bpy_script_paths, METH_NOARGS, bpy_script_paths_doc};
|
||||
static PyMethodDef meth_bpy_blend_paths = {"blend_paths", (PyCFunction)bpy_blend_paths, METH_VARARGS|METH_KEYWORDS, bpy_blend_paths_doc};
|
||||
static PyMethodDef meth_bpy_user_resource = {"user_resource", (PyCFunction)bpy_user_resource, METH_VARARGS|METH_KEYWORDS, NULL};
|
||||
static PyMethodDef meth_bpy_script_paths= {"script_paths", (PyCFunction)bpy_script_paths, METH_NOARGS, bpy_script_paths_doc};
|
||||
static PyMethodDef meth_bpy_blend_paths= {"blend_paths", (PyCFunction)bpy_blend_paths, METH_VARARGS|METH_KEYWORDS, bpy_blend_paths_doc};
|
||||
static PyMethodDef meth_bpy_user_resource= {"user_resource", (PyCFunction)bpy_user_resource, METH_VARARGS|METH_KEYWORDS, NULL};
|
||||
|
||||
static PyObject *bpy_import_test(const char *modname)
|
||||
{
|
||||
@ -209,7 +209,7 @@ void BPy_init_modules( void )
|
||||
/* stand alone utility modules not related to blender directly */
|
||||
IDProp_Init_Types(); /* not actually a submodule, just types */
|
||||
|
||||
mod = PyModule_New("_bpy");
|
||||
mod= PyModule_New("_bpy");
|
||||
|
||||
/* add the module so we can import it */
|
||||
PyDict_SetItemString(PyImport_GetModuleDict(), "_bpy", mod);
|
||||
|
@ -56,7 +56,7 @@ extern char build_system[];
|
||||
|
||||
static PyTypeObject BlenderAppType;
|
||||
|
||||
static PyStructSequence_Field app_info_fields[] = {
|
||||
static PyStructSequence_Field app_info_fields[]= {
|
||||
{(char *)"version", (char *)"The Blender version as a tuple of 3 numbers. eg. (2, 50, 11)"},
|
||||
{(char *)"version_string", (char *)"The Blender version formatted as a string"},
|
||||
{(char *)"binary_path", (char *)"The location of blenders executable, useful for utilities that spawn new instances"},
|
||||
@ -75,7 +75,7 @@ static PyStructSequence_Field app_info_fields[] = {
|
||||
{NULL}
|
||||
};
|
||||
|
||||
static PyStructSequence_Desc app_info_desc = {
|
||||
static PyStructSequence_Desc app_info_desc= {
|
||||
(char *)"bpy.app", /* name */
|
||||
(char *)"This module contains application values that remain unchanged during runtime.", /* doc */
|
||||
app_info_fields, /* fields */
|
||||
@ -87,9 +87,9 @@ static PyObject *make_app_info(void)
|
||||
extern char bprogname[]; /* argv[0] from creator.c */
|
||||
|
||||
PyObject *app_info;
|
||||
int pos = 0;
|
||||
int pos= 0;
|
||||
|
||||
app_info = PyStructSequence_New(&BlenderAppType);
|
||||
app_info= PyStructSequence_New(&BlenderAppType);
|
||||
if (app_info == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
@ -229,8 +229,8 @@ PyObject *BPY_app_struct(void)
|
||||
ret= make_app_info();
|
||||
|
||||
/* prevent user from creating new instances */
|
||||
BlenderAppType.tp_init = NULL;
|
||||
BlenderAppType.tp_new = NULL;
|
||||
BlenderAppType.tp_init= NULL;
|
||||
BlenderAppType.tp_new= NULL;
|
||||
|
||||
/* kindof a hack ontop of PyStructSequence */
|
||||
py_struct_seq_getset_init();
|
||||
|
@ -42,7 +42,7 @@
|
||||
#include "bpy_driver.h"
|
||||
|
||||
/* for pydrivers (drivers using one-line Python expressions to express relationships between targets) */
|
||||
PyObject *bpy_pydriver_Dict = NULL;
|
||||
PyObject *bpy_pydriver_Dict= NULL;
|
||||
|
||||
/* For faster execution we keep a special dictionary for pydrivers, with
|
||||
* the needed modules and aliases.
|
||||
@ -54,16 +54,16 @@ int bpy_pydriver_create_dict(void)
|
||||
/* validate namespace for driver evaluation */
|
||||
if (bpy_pydriver_Dict) return -1;
|
||||
|
||||
d = PyDict_New();
|
||||
d= PyDict_New();
|
||||
if (d == NULL)
|
||||
return -1;
|
||||
else
|
||||
bpy_pydriver_Dict = d;
|
||||
bpy_pydriver_Dict= d;
|
||||
|
||||
/* import some modules: builtins, bpy, math, (Blender.noise )*/
|
||||
PyDict_SetItemString(d, "__builtins__", PyEval_GetBuiltins());
|
||||
|
||||
mod = PyImport_ImportModule("math");
|
||||
mod= PyImport_ImportModule("math");
|
||||
if (mod) {
|
||||
PyDict_Merge(d, PyModule_GetDict(mod), 0); /* 0 - dont overwrite existing values */
|
||||
Py_DECREF(mod);
|
||||
@ -90,12 +90,12 @@ void BPY_driver_reset(void)
|
||||
int use_gil= 1; // (PyThreadState_Get()==NULL);
|
||||
|
||||
if(use_gil)
|
||||
gilstate = PyGILState_Ensure();
|
||||
gilstate= PyGILState_Ensure();
|
||||
|
||||
if (bpy_pydriver_Dict) { /* free the global dict used by pydrivers */
|
||||
PyDict_Clear(bpy_pydriver_Dict);
|
||||
Py_DECREF(bpy_pydriver_Dict);
|
||||
bpy_pydriver_Dict = NULL;
|
||||
bpy_pydriver_Dict= NULL;
|
||||
}
|
||||
|
||||
if(use_gil)
|
||||
@ -132,13 +132,13 @@ float BPY_driver_exec(ChannelDriver *driver)
|
||||
int use_gil;
|
||||
|
||||
DriverVar *dvar;
|
||||
double result = 0.0; /* default return */
|
||||
char *expr = NULL;
|
||||
double result= 0.0; /* default return */
|
||||
char *expr= NULL;
|
||||
short targets_ok= 1;
|
||||
int i;
|
||||
|
||||
/* get the py expression to be evaluated */
|
||||
expr = driver->expression;
|
||||
expr= driver->expression;
|
||||
if ((expr == NULL) || (expr[0]=='\0'))
|
||||
return 0.0f;
|
||||
|
||||
@ -150,7 +150,7 @@ float BPY_driver_exec(ChannelDriver *driver)
|
||||
use_gil= 1; //(PyThreadState_Get()==NULL);
|
||||
|
||||
if(use_gil)
|
||||
gilstate = PyGILState_Ensure();
|
||||
gilstate= PyGILState_Ensure();
|
||||
|
||||
/* init global dictionary for py-driver evaluation settings */
|
||||
if (!bpy_pydriver_Dict) {
|
||||
@ -200,10 +200,10 @@ float BPY_driver_exec(ChannelDriver *driver)
|
||||
}
|
||||
|
||||
/* add target values to a dict that will be used as '__locals__' dict */
|
||||
driver_vars = PyDict_New(); // XXX do we need to decref this?
|
||||
driver_vars= PyDict_New(); // XXX do we need to decref this?
|
||||
for (dvar= driver->variables.first, i=0; dvar; dvar= dvar->next) {
|
||||
PyObject *driver_arg = NULL;
|
||||
float tval = 0.0f;
|
||||
PyObject *driver_arg= NULL;
|
||||
float tval= 0.0f;
|
||||
|
||||
/* try to get variable value */
|
||||
tval= driver_get_variable_value(driver, dvar);
|
||||
@ -228,7 +228,7 @@ float BPY_driver_exec(ChannelDriver *driver)
|
||||
|
||||
#if 0 // slow, with this can avoid all Py_CompileString above.
|
||||
/* execute expression to get a value */
|
||||
retval = PyRun_String(expr, Py_eval_input, bpy_pydriver_Dict, driver_vars);
|
||||
retval= PyRun_String(expr, Py_eval_input, bpy_pydriver_Dict, driver_vars);
|
||||
#else
|
||||
/* evaluate the compiled expression */
|
||||
if (expr_code)
|
||||
@ -241,10 +241,11 @@ float BPY_driver_exec(ChannelDriver *driver)
|
||||
/* process the result */
|
||||
if (retval == NULL) {
|
||||
pydriver_error(driver);
|
||||
} else if((result= PyFloat_AsDouble(retval)) == -1.0 && PyErr_Occurred()) {
|
||||
}
|
||||
else if((result= PyFloat_AsDouble(retval)) == -1.0 && PyErr_Occurred()) {
|
||||
pydriver_error(driver);
|
||||
Py_DECREF(retval);
|
||||
result = 0.0;
|
||||
result= 0.0;
|
||||
}
|
||||
else {
|
||||
/* all fine, make sure the "invalid expression" flag is cleared */
|
||||
|
@ -80,7 +80,7 @@ BPy_StructRNA *bpy_context_module= NULL; /* for fast access */
|
||||
|
||||
#ifdef TIME_PY_RUN
|
||||
#include "PIL_time.h"
|
||||
static int bpy_timer_count = 0;
|
||||
static int bpy_timer_count= 0;
|
||||
static double bpy_timer; /* time since python starts */
|
||||
static double bpy_timer_run; /* time for each python script run */
|
||||
static double bpy_timer_run_tot; /* accumulate python runs */
|
||||
@ -91,7 +91,7 @@ void bpy_context_set(bContext *C, PyGILState_STATE *gilstate)
|
||||
py_call_level++;
|
||||
|
||||
if(gilstate)
|
||||
*gilstate = PyGILState_Ensure();
|
||||
*gilstate= PyGILState_Ensure();
|
||||
|
||||
if(py_call_level==1) {
|
||||
|
||||
@ -109,7 +109,7 @@ void bpy_context_set(bContext *C, PyGILState_STATE *gilstate)
|
||||
if(bpy_timer_count==0) {
|
||||
/* record time from the beginning */
|
||||
bpy_timer= PIL_check_seconds_timer();
|
||||
bpy_timer_run = bpy_timer_run_tot = 0.0;
|
||||
bpy_timer_run= bpy_timer_run_tot= 0.0;
|
||||
}
|
||||
bpy_timer_run= PIL_check_seconds_timer();
|
||||
|
||||
@ -145,9 +145,9 @@ void bpy_context_clear(bContext *UNUSED(C), PyGILState_STATE *gilstate)
|
||||
|
||||
void BPY_text_free_code(Text *text)
|
||||
{
|
||||
if( text->compiled ) {
|
||||
Py_DECREF( ( PyObject * ) text->compiled );
|
||||
text->compiled = NULL;
|
||||
if(text->compiled) {
|
||||
Py_DECREF((PyObject *)text->compiled);
|
||||
text->compiled= NULL;
|
||||
}
|
||||
}
|
||||
|
||||
@ -155,8 +155,8 @@ void BPY_modules_update(bContext *C)
|
||||
{
|
||||
#if 0 // slow, this runs all the time poll, draw etc 100's of time a sec.
|
||||
PyObject *mod= PyImport_ImportModuleLevel("bpy", NULL, NULL, NULL, 0);
|
||||
PyModule_AddObject( mod, "data", BPY_rna_module() );
|
||||
PyModule_AddObject( mod, "types", BPY_rna_types() ); // atm this does not need updating
|
||||
PyModule_AddObject(mod, "data", BPY_rna_module());
|
||||
PyModule_AddObject(mod, "types", BPY_rna_types()); // atm this does not need updating
|
||||
#endif
|
||||
|
||||
/* refreshes the main struct */
|
||||
@ -228,7 +228,7 @@ static struct _inittab bpy_internal_modules[]= {
|
||||
void BPY_python_start(int argc, const char **argv)
|
||||
{
|
||||
#ifndef WITH_PYTHON_MODULE
|
||||
PyThreadState *py_tstate = NULL;
|
||||
PyThreadState *py_tstate= NULL;
|
||||
|
||||
/* not essential but nice to set our name */
|
||||
static wchar_t bprogname_wchar[FILE_MAXDIR+FILE_MAXFILE]; /* python holds a reference */
|
||||
@ -245,9 +245,9 @@ void BPY_python_start(int argc, const char **argv)
|
||||
* alternatively we could copy the file. */
|
||||
Py_NoSiteFlag= 1;
|
||||
|
||||
Py_Initialize( );
|
||||
Py_Initialize();
|
||||
|
||||
// PySys_SetArgv( argc, argv); // broken in py3, not a huge deal
|
||||
// PySys_SetArgv(argc, argv); // broken in py3, not a huge deal
|
||||
/* sigh, why do python guys not have a char** version anymore? :( */
|
||||
{
|
||||
int i;
|
||||
@ -274,9 +274,9 @@ void BPY_python_start(int argc, const char **argv)
|
||||
{ /* our own import and reload functions */
|
||||
PyObject *item;
|
||||
PyObject *mod;
|
||||
//PyObject *m = PyImport_AddModule("__builtin__");
|
||||
//PyObject *d = PyModule_GetDict(m);
|
||||
PyObject *d = PyEval_GetBuiltins( );
|
||||
//PyObject *m= PyImport_AddModule("__builtin__");
|
||||
//PyObject *d= PyModule_GetDict(m);
|
||||
PyObject *d= PyEval_GetBuiltins();
|
||||
// PyDict_SetItemString(d, "reload", item=PyCFunction_New(&bpy_reload_meth, NULL)); Py_DECREF(item);
|
||||
PyDict_SetItemString(d, "__import__", item=PyCFunction_New(&bpy_import_meth, NULL)); Py_DECREF(item);
|
||||
|
||||
@ -296,7 +296,7 @@ void BPY_python_start(int argc, const char **argv)
|
||||
pyrna_alloc_types();
|
||||
|
||||
#ifndef WITH_PYTHON_MODULE
|
||||
py_tstate = PyGILState_GetThisThreadState();
|
||||
py_tstate= PyGILState_GetThisThreadState();
|
||||
PyEval_ReleaseThread(py_tstate);
|
||||
#endif
|
||||
}
|
||||
@ -312,11 +312,11 @@ void BPY_python_end(void)
|
||||
|
||||
/* clear all python data from structs */
|
||||
|
||||
Py_Finalize( );
|
||||
Py_Finalize();
|
||||
|
||||
#ifdef TIME_PY_RUN
|
||||
// measure time since py started
|
||||
bpy_timer = PIL_check_seconds_timer() - bpy_timer;
|
||||
bpy_timer= PIL_check_seconds_timer() - bpy_timer;
|
||||
|
||||
printf("*bpy stats* - ");
|
||||
printf("tot exec: %d, ", bpy_timer_count);
|
||||
@ -380,13 +380,12 @@ static int python_script_exec(bContext *C, const char *fn, struct Text *text, st
|
||||
char fn_dummy[FILE_MAXDIR];
|
||||
bpy_text_filename_get(fn_dummy, sizeof(fn_dummy), text);
|
||||
|
||||
if( !text->compiled ) { /* if it wasn't already compiled, do it now */
|
||||
char *buf = txt_to_buf( text );
|
||||
if(text->compiled == NULL) { /* if it wasn't already compiled, do it now */
|
||||
char *buf= txt_to_buf(text);
|
||||
|
||||
text->compiled =
|
||||
Py_CompileString( buf, fn_dummy, Py_file_input );
|
||||
text->compiled= Py_CompileString(buf, fn_dummy, Py_file_input);
|
||||
|
||||
MEM_freeN( buf );
|
||||
MEM_freeN(buf);
|
||||
|
||||
if(PyErr_Occurred()) {
|
||||
if(do_jump) {
|
||||
@ -397,8 +396,8 @@ static int python_script_exec(bContext *C, const char *fn, struct Text *text, st
|
||||
}
|
||||
|
||||
if(text->compiled) {
|
||||
py_dict = PyC_DefaultNameSpace(fn_dummy);
|
||||
py_result = PyEval_EvalCode(text->compiled, py_dict, py_dict);
|
||||
py_dict= PyC_DefaultNameSpace(fn_dummy);
|
||||
py_result= PyEval_EvalCode(text->compiled, py_dict, py_dict);
|
||||
}
|
||||
|
||||
}
|
||||
@ -406,7 +405,7 @@ static int python_script_exec(bContext *C, const char *fn, struct Text *text, st
|
||||
FILE *fp= fopen(fn, "r");
|
||||
|
||||
if(fp) {
|
||||
py_dict = PyC_DefaultNameSpace(fn);
|
||||
py_dict= PyC_DefaultNameSpace(fn);
|
||||
|
||||
#ifdef _WIN32
|
||||
/* Previously we used PyRun_File to run directly the code on a FILE
|
||||
@ -422,11 +421,11 @@ static int python_script_exec(bContext *C, const char *fn, struct Text *text, st
|
||||
pystring= MEM_mallocN(strlen(fn) + 32, "pystring");
|
||||
pystring[0]= '\0';
|
||||
sprintf(pystring, "exec(open(r'%s').read())", fn);
|
||||
py_result = PyRun_String( pystring, Py_file_input, py_dict, py_dict );
|
||||
py_result= PyRun_String(pystring, Py_file_input, py_dict, py_dict);
|
||||
MEM_freeN(pystring);
|
||||
}
|
||||
#else
|
||||
py_result = PyRun_File(fp, fn, Py_file_input, py_dict, py_dict);
|
||||
py_result= PyRun_File(fp, fn, Py_file_input, py_dict, py_dict);
|
||||
fclose(fp);
|
||||
#endif
|
||||
}
|
||||
@ -443,14 +442,15 @@ static int python_script_exec(bContext *C, const char *fn, struct Text *text, st
|
||||
}
|
||||
}
|
||||
BPy_errors_to_report(reports);
|
||||
} else {
|
||||
Py_DECREF( py_result );
|
||||
}
|
||||
else {
|
||||
Py_DECREF(py_result);
|
||||
}
|
||||
|
||||
if(py_dict) {
|
||||
#ifdef PYMODULE_CLEAR_WORKAROUND
|
||||
PyModuleObject *mmod= (PyModuleObject *)PyDict_GetItemString(PyThreadState_GET()->interp->modules, "__main__");
|
||||
PyObject *dict_back = mmod->md_dict;
|
||||
PyObject *dict_back= mmod->md_dict;
|
||||
/* freeing the module will clear the namespace,
|
||||
* gives problems running classes defined in this namespace being used later. */
|
||||
mmod->md_dict= NULL;
|
||||
@ -481,7 +481,7 @@ int BPY_text_exec(bContext *C, struct Text *text, struct ReportList *reports, co
|
||||
|
||||
void BPY_DECREF(void *pyob_ptr)
|
||||
{
|
||||
PyGILState_STATE gilstate = PyGILState_Ensure();
|
||||
PyGILState_STATE gilstate= PyGILState_Ensure();
|
||||
Py_DECREF((PyObject *)pyob_ptr);
|
||||
PyGILState_Release(gilstate);
|
||||
}
|
||||
@ -490,7 +490,7 @@ int BPY_button_exec(bContext *C, const char *expr, double *value)
|
||||
{
|
||||
PyGILState_STATE gilstate;
|
||||
PyObject *py_dict, *mod, *retval;
|
||||
int error_ret = 0;
|
||||
int error_ret= 0;
|
||||
PyObject *main_mod= NULL;
|
||||
|
||||
if (!value || !expr) return -1;
|
||||
@ -506,7 +506,7 @@ int BPY_button_exec(bContext *C, const char *expr, double *value)
|
||||
|
||||
py_dict= PyC_DefaultNameSpace("<blender button>");
|
||||
|
||||
mod = PyImport_ImportModule("math");
|
||||
mod= PyImport_ImportModule("math");
|
||||
if (mod) {
|
||||
PyDict_Merge(py_dict, PyModule_GetDict(mod), 0); /* 0 - dont overwrite existing values */
|
||||
Py_DECREF(mod);
|
||||
@ -516,7 +516,7 @@ int BPY_button_exec(bContext *C, const char *expr, double *value)
|
||||
PyErr_Clear();
|
||||
}
|
||||
|
||||
retval = PyRun_String(expr, Py_eval_input, py_dict, py_dict);
|
||||
retval= PyRun_String(expr, Py_eval_input, py_dict, py_dict);
|
||||
|
||||
if (retval == NULL) {
|
||||
error_ret= -1;
|
||||
@ -535,7 +535,7 @@ int BPY_button_exec(bContext *C, const char *expr, double *value)
|
||||
}
|
||||
}
|
||||
else {
|
||||
val = PyFloat_AsDouble(retval);
|
||||
val= PyFloat_AsDouble(retval);
|
||||
}
|
||||
Py_DECREF(retval);
|
||||
|
||||
@ -566,7 +566,7 @@ int BPY_string_exec(bContext *C, const char *expr)
|
||||
PyGILState_STATE gilstate;
|
||||
PyObject *main_mod= NULL;
|
||||
PyObject *py_dict, *retval;
|
||||
int error_ret = 0;
|
||||
int error_ret= 0;
|
||||
|
||||
if (!expr) return -1;
|
||||
|
||||
@ -580,7 +580,7 @@ int BPY_string_exec(bContext *C, const char *expr)
|
||||
|
||||
py_dict= PyC_DefaultNameSpace("<blender string>");
|
||||
|
||||
retval = PyRun_String(expr, Py_eval_input, py_dict, py_dict);
|
||||
retval= PyRun_String(expr, Py_eval_input, py_dict, py_dict);
|
||||
|
||||
if (retval == NULL) {
|
||||
error_ret= -1;
|
||||
@ -661,7 +661,7 @@ int BPY_context_member_get(bContext *C, const char *member, bContextDataResult *
|
||||
else {
|
||||
int len= PySequence_Fast_GET_SIZE(seq_fast);
|
||||
int i;
|
||||
for(i = 0; i < len; i++) {
|
||||
for(i= 0; i < len; i++) {
|
||||
PyObject *list_item= PySequence_Fast_GET_ITEM(seq_fast, i);
|
||||
|
||||
if(BPy_StructRNA_Check(list_item)) {
|
||||
@ -701,7 +701,7 @@ int BPY_context_member_get(bContext *C, const char *member, bContextDataResult *
|
||||
/* TODO, reloading the module isnt functional at the moment. */
|
||||
|
||||
extern int main_python(int argc, const char **argv);
|
||||
static struct PyModuleDef bpy_proxy_def = {
|
||||
static struct PyModuleDef bpy_proxy_def= {
|
||||
PyModuleDef_HEAD_INIT,
|
||||
"bpy", /* m_name */
|
||||
NULL, /* m_doc */
|
||||
@ -744,7 +744,7 @@ void bpy_module_delay_init(PyObject *bpy_proxy)
|
||||
|
||||
static void dealloc_obj_dealloc(PyObject *self);
|
||||
|
||||
static PyTypeObject dealloc_obj_Type = {{{0}}};
|
||||
static PyTypeObject dealloc_obj_Type= {{{0}}};
|
||||
|
||||
/* use our own dealloc so we can free a property if we use one */
|
||||
static void dealloc_obj_dealloc(PyObject *self)
|
||||
@ -778,10 +778,10 @@ PyInit_bpy(void)
|
||||
dealloc_obj *dob;
|
||||
|
||||
/* assign dummy type */
|
||||
dealloc_obj_Type.tp_name = "dealloc_obj";
|
||||
dealloc_obj_Type.tp_basicsize = sizeof(dealloc_obj);
|
||||
dealloc_obj_Type.tp_dealloc = dealloc_obj_dealloc;
|
||||
dealloc_obj_Type.tp_flags = Py_TPFLAGS_DEFAULT;
|
||||
dealloc_obj_Type.tp_name= "dealloc_obj";
|
||||
dealloc_obj_Type.tp_basicsize= sizeof(dealloc_obj);
|
||||
dealloc_obj_Type.tp_dealloc= dealloc_obj_dealloc;
|
||||
dealloc_obj_Type.tp_flags= Py_TPFLAGS_DEFAULT;
|
||||
|
||||
if(PyType_Ready(&dealloc_obj_Type) < 0)
|
||||
return NULL;
|
||||
|
@ -62,7 +62,7 @@ static PyObject *bpy_lib_enter(BPy_Library *self, PyObject *args);
|
||||
static PyObject *bpy_lib_exit(BPy_Library *self, PyObject *args);
|
||||
static PyObject *bpy_lib_dir(BPy_Library *self);
|
||||
|
||||
static PyMethodDef bpy_lib_methods[] = {
|
||||
static PyMethodDef bpy_lib_methods[]= {
|
||||
{"__enter__", (PyCFunction)bpy_lib_enter, METH_NOARGS},
|
||||
{"__exit__", (PyCFunction)bpy_lib_exit, METH_VARARGS},
|
||||
{"__dir__", (PyCFunction)bpy_lib_dir, METH_NOARGS},
|
||||
@ -76,7 +76,7 @@ static void bpy_lib_dealloc(BPy_Library *self)
|
||||
}
|
||||
|
||||
|
||||
PyTypeObject bpy_lib_Type = {
|
||||
PyTypeObject bpy_lib_Type= {
|
||||
PyVarObject_HEAD_INIT(NULL, 0)
|
||||
"bpy_lib", /* tp_name */
|
||||
sizeof(BPy_Library), /* tp_basicsize */
|
||||
@ -170,9 +170,9 @@ static char bpy_lib_load_doc[] =
|
||||
;
|
||||
static PyObject *bpy_lib_load(PyObject *UNUSED(self), PyObject *args, PyObject *kwds)
|
||||
{
|
||||
static const char *kwlist[] = {"filepath", "link", "relative", NULL};
|
||||
static const char *kwlist[]= {"filepath", "link", "relative", NULL};
|
||||
BPy_Library *ret;
|
||||
const char* filename = NULL;
|
||||
const char* filename= NULL;
|
||||
int is_rel= 0, is_link= 0;
|
||||
|
||||
if(!PyArg_ParseTupleAndKeywords(args, kwds, "s|ii:load", (char **)kwlist, &filename, &is_link, &is_rel))
|
||||
@ -202,9 +202,9 @@ static PyObject *_bpy_names(BPy_Library *self, int blocktype)
|
||||
names= BLO_blendhandle_get_datablock_names(self->blo_handle, blocktype, &totnames);
|
||||
|
||||
if(names) {
|
||||
int counter = 0;
|
||||
list = PyList_New(totnames);
|
||||
for(l = names; l; l = l->next) {
|
||||
int counter= 0;
|
||||
list= PyList_New(totnames);
|
||||
for(l= names; l; l= l->next) {
|
||||
PyList_SET_ITEM(list, counter, PyUnicode_FromString((char * )l->link));
|
||||
counter++;
|
||||
}
|
||||
@ -277,7 +277,7 @@ static PyObject *bpy_lib_exit(BPy_Library *self, PyObject *UNUSED(args))
|
||||
flag_all_listbases_ids(LIB_PRE_EXISTING, 1);
|
||||
|
||||
/* here appending/linking starts */
|
||||
mainl = BLO_library_append_begin(BPy_GetContext(), &(self->blo_handle), self->relpath);
|
||||
mainl= BLO_library_append_begin(BPy_GetContext(), &(self->blo_handle), self->relpath);
|
||||
|
||||
{
|
||||
int i= 0, code;
|
||||
|
@ -118,7 +118,7 @@ static PyObject *pyop_poll(PyObject *UNUSED(self), PyObject *args)
|
||||
static PyObject *pyop_call(PyObject *UNUSED(self), PyObject *args)
|
||||
{
|
||||
wmOperatorType *ot;
|
||||
int error_val = 0;
|
||||
int error_val= 0;
|
||||
PointerRNA ptr;
|
||||
int operator_ret= OPERATOR_CANCELLED;
|
||||
|
||||
@ -132,7 +132,7 @@ static PyObject *pyop_call(PyObject *UNUSED(self), PyObject *args)
|
||||
int context= WM_OP_EXEC_DEFAULT;
|
||||
|
||||
// XXX Todo, work out a better solution for passing on context, could make a tuple from self and pack the name and Context into it...
|
||||
bContext *C = (bContext *)BPy_GetContext();
|
||||
bContext *C= (bContext *)BPy_GetContext();
|
||||
|
||||
if(C==NULL) {
|
||||
PyErr_SetString(PyExc_RuntimeError, "Context is None, cant poll any operators");
|
||||
@ -259,10 +259,10 @@ static PyObject *pyop_as_string(PyObject *UNUSED(self), PyObject *args)
|
||||
|
||||
char *opname;
|
||||
PyObject *kw= NULL; /* optional args */
|
||||
int all_args = 1;
|
||||
int all_args= 1;
|
||||
int error_val= 0;
|
||||
|
||||
char *buf = NULL;
|
||||
char *buf= NULL;
|
||||
PyObject *pybuf;
|
||||
|
||||
bContext *C= (bContext *)BPy_GetContext();
|
||||
@ -311,11 +311,11 @@ static PyObject *pyop_as_string(PyObject *UNUSED(self), PyObject *args)
|
||||
|
||||
static PyObject *pyop_dir(PyObject *UNUSED(self))
|
||||
{
|
||||
PyObject *list = PyList_New(0), *name;
|
||||
PyObject *list= PyList_New(0), *name;
|
||||
wmOperatorType *ot;
|
||||
|
||||
for(ot= WM_operatortype_first(); ot; ot= ot->next) {
|
||||
name = PyUnicode_FromString(ot->idname);
|
||||
name= PyUnicode_FromString(ot->idname);
|
||||
PyList_Append(list, name);
|
||||
Py_DECREF(name);
|
||||
}
|
||||
@ -353,7 +353,7 @@ static PyObject *pyop_getrna(PyObject *UNUSED(self), PyObject *value)
|
||||
return (PyObject *)pyrna;
|
||||
}
|
||||
|
||||
static struct PyMethodDef bpy_ops_methods[] = {
|
||||
static struct PyMethodDef bpy_ops_methods[]= {
|
||||
{"poll", (PyCFunction) pyop_poll, METH_VARARGS, NULL},
|
||||
{"call", (PyCFunction) pyop_call, METH_VARARGS, NULL},
|
||||
{"as_string", (PyCFunction) pyop_as_string, METH_VARARGS, NULL},
|
||||
@ -363,7 +363,7 @@ static struct PyMethodDef bpy_ops_methods[] = {
|
||||
{NULL, NULL, 0, NULL}
|
||||
};
|
||||
|
||||
static struct PyModuleDef bpy_ops_module = {
|
||||
static struct PyModuleDef bpy_ops_module= {
|
||||
PyModuleDef_HEAD_INIT,
|
||||
"_bpy.ops",
|
||||
NULL,
|
||||
|
@ -43,7 +43,7 @@
|
||||
|
||||
static void operator_properties_init(wmOperatorType *ot)
|
||||
{
|
||||
PyObject *py_class = ot->ext.data;
|
||||
PyObject *py_class= ot->ext.data;
|
||||
RNA_struct_blender_type_set(ot->ext.srna, ot);
|
||||
|
||||
/* only call this so pyrna_deferred_register_class gives a useful error
|
||||
@ -61,7 +61,7 @@ void operator_wrapper(wmOperatorType *ot, void *userdata)
|
||||
{
|
||||
/* take care not to overwrite anything set in
|
||||
* WM_operatortype_append_ptr before opfunc() is called */
|
||||
StructRNA *srna = ot->srna;
|
||||
StructRNA *srna= ot->srna;
|
||||
*ot= *((wmOperatorType *)userdata);
|
||||
ot->srna= srna; /* restore */
|
||||
|
||||
@ -72,7 +72,7 @@ void operator_wrapper(wmOperatorType *ot, void *userdata)
|
||||
PropertyRNA *prop;
|
||||
|
||||
RNA_pointer_create(NULL, ot->srna, NULL, &ptr);
|
||||
prop = RNA_struct_find_property(&ptr, "type");
|
||||
prop= RNA_struct_find_property(&ptr, "type");
|
||||
if(prop)
|
||||
ot->prop= prop;
|
||||
}
|
||||
@ -80,16 +80,16 @@ void operator_wrapper(wmOperatorType *ot, void *userdata)
|
||||
|
||||
void macro_wrapper(wmOperatorType *ot, void *userdata)
|
||||
{
|
||||
wmOperatorType *data = (wmOperatorType *)userdata;
|
||||
wmOperatorType *data= (wmOperatorType *)userdata;
|
||||
|
||||
/* only copy a couple of things, the rest is set by the macro registration */
|
||||
ot->name = data->name;
|
||||
ot->idname = data->idname;
|
||||
ot->description = data->description;
|
||||
ot->name= data->name;
|
||||
ot->idname= data->idname;
|
||||
ot->description= data->description;
|
||||
ot->flag |= data->flag; /* append flags to the one set by registration */
|
||||
ot->pyop_poll = data->pyop_poll;
|
||||
ot->ui = data->ui;
|
||||
ot->ext = data->ext;
|
||||
ot->pyop_poll= data->pyop_poll;
|
||||
ot->ui= data->ui;
|
||||
ot->ext= data->ext;
|
||||
|
||||
operator_properties_init(ot);
|
||||
}
|
||||
@ -115,16 +115,16 @@ PyObject *PYOP_wrap_macro_define(PyObject *UNUSED(self), PyObject *args)
|
||||
|
||||
/* identifiers */
|
||||
srna= srna_from_self(macro, "Macro Define:");
|
||||
macroname = RNA_struct_identifier(srna);
|
||||
macroname= RNA_struct_identifier(srna);
|
||||
|
||||
ot = WM_operatortype_find(macroname, TRUE);
|
||||
ot= WM_operatortype_find(macroname, TRUE);
|
||||
|
||||
if (!ot) {
|
||||
PyErr_Format(PyExc_ValueError, "Macro Define: '%s' is not a valid macro or hasn't been registered yet", macroname);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
otmacro = WM_operatortype_macro_define(ot, opname);
|
||||
otmacro= WM_operatortype_macro_define(ot, opname);
|
||||
|
||||
RNA_pointer_create(NULL, &RNA_OperatorTypeMacro, otmacro, &ptr_otmacro);
|
||||
|
||||
|
@ -47,19 +47,19 @@
|
||||
|
||||
#include "../generic/py_capi_utils.h"
|
||||
|
||||
static EnumPropertyItem property_flag_items[] = {
|
||||
static EnumPropertyItem property_flag_items[]= {
|
||||
{PROP_HIDDEN, "HIDDEN", 0, "Hidden", ""},
|
||||
{PROP_ANIMATABLE, "ANIMATABLE", 0, "Animateable", ""},
|
||||
{0, NULL, 0, NULL, NULL}};
|
||||
|
||||
static EnumPropertyItem property_flag_enum_items[] = {
|
||||
static EnumPropertyItem property_flag_enum_items[]= {
|
||||
{PROP_HIDDEN, "HIDDEN", 0, "Hidden", ""},
|
||||
{PROP_ANIMATABLE, "ANIMATABLE", 0, "Animateable", ""},
|
||||
{PROP_ENUM_FLAG, "ENUM_FLAG", 0, "Enum Flag", ""},
|
||||
{0, NULL, 0, NULL, NULL}};
|
||||
|
||||
/* subtypes */
|
||||
static EnumPropertyItem property_subtype_string_items[] = {
|
||||
static EnumPropertyItem property_subtype_string_items[]= {
|
||||
{PROP_FILEPATH, "FILE_PATH", 0, "File Path", ""},
|
||||
{PROP_DIRPATH, "DIR_PATH", 0, "Directory Path", ""},
|
||||
{PROP_FILENAME, "FILENAME", 0, "Filename", ""},
|
||||
@ -67,7 +67,7 @@ static EnumPropertyItem property_subtype_string_items[] = {
|
||||
{PROP_NONE, "NONE", 0, "None", ""},
|
||||
{0, NULL, 0, NULL, NULL}};
|
||||
|
||||
static EnumPropertyItem property_subtype_number_items[] = {
|
||||
static EnumPropertyItem property_subtype_number_items[]= {
|
||||
{PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned", ""},
|
||||
{PROP_PERCENTAGE, "PERCENTAGE", 0, "Percentage", ""},
|
||||
{PROP_FACTOR, "FACTOR", 0, "Factor", ""},
|
||||
@ -78,7 +78,7 @@ static EnumPropertyItem property_subtype_number_items[] = {
|
||||
{PROP_NONE, "NONE", 0, "None", ""},
|
||||
{0, NULL, 0, NULL, NULL}};
|
||||
|
||||
static EnumPropertyItem property_subtype_array_items[] = {
|
||||
static EnumPropertyItem property_subtype_array_items[]= {
|
||||
{PROP_COLOR, "COLOR", 0, "Color", ""},
|
||||
{PROP_TRANSLATION, "TRANSLATION", 0, "Translation", ""},
|
||||
{PROP_DIRECTION, "DIRECTION", 0, "Direction", ""},
|
||||
@ -96,17 +96,17 @@ static EnumPropertyItem property_subtype_array_items[] = {
|
||||
{0, NULL, 0, NULL, NULL}};
|
||||
|
||||
/* PyObject's */
|
||||
static PyObject *pymeth_BoolProperty = NULL;
|
||||
static PyObject *pymeth_BoolVectorProperty = NULL;
|
||||
static PyObject *pymeth_IntProperty = NULL;
|
||||
static PyObject *pymeth_IntVectorProperty = NULL;
|
||||
static PyObject *pymeth_FloatProperty = NULL;
|
||||
static PyObject *pymeth_FloatVectorProperty = NULL;
|
||||
static PyObject *pymeth_StringProperty = NULL;
|
||||
static PyObject *pymeth_EnumProperty = NULL;
|
||||
static PyObject *pymeth_PointerProperty = NULL;
|
||||
static PyObject *pymeth_CollectionProperty = NULL;
|
||||
static PyObject *pymeth_RemoveProperty = NULL;
|
||||
static PyObject *pymeth_BoolProperty= NULL;
|
||||
static PyObject *pymeth_BoolVectorProperty= NULL;
|
||||
static PyObject *pymeth_IntProperty= NULL;
|
||||
static PyObject *pymeth_IntVectorProperty= NULL;
|
||||
static PyObject *pymeth_FloatProperty= NULL;
|
||||
static PyObject *pymeth_FloatVectorProperty= NULL;
|
||||
static PyObject *pymeth_StringProperty= NULL;
|
||||
static PyObject *pymeth_EnumProperty= NULL;
|
||||
static PyObject *pymeth_PointerProperty= NULL;
|
||||
static PyObject *pymeth_CollectionProperty= NULL;
|
||||
static PyObject *pymeth_RemoveProperty= NULL;
|
||||
|
||||
|
||||
/* operators and classes use this so it can store the args given but defer
|
||||
@ -114,7 +114,7 @@ static PyObject *pymeth_RemoveProperty = NULL;
|
||||
* the default args for that operator instance */
|
||||
static PyObject *bpy_prop_deferred_return(PyObject *func, PyObject *kw)
|
||||
{
|
||||
PyObject *ret = PyTuple_New(2);
|
||||
PyObject *ret= PyTuple_New(2);
|
||||
PyTuple_SET_ITEM(ret, 0, func);
|
||||
Py_INCREF(func);
|
||||
|
||||
@ -213,7 +213,7 @@ static PyObject *BPy_BoolProperty(PyObject *self, PyObject *args, PyObject *kw)
|
||||
BPY_PROPDEF_HEAD(BoolProperty)
|
||||
|
||||
if(srna) {
|
||||
static const char *kwlist[] = {"attr", "name", "description", "default", "options", "subtype", NULL};
|
||||
static const char *kwlist[]= {"attr", "name", "description", "default", "options", "subtype", NULL};
|
||||
const char *id=NULL, *name="", *description="";
|
||||
int id_len;
|
||||
int def=0;
|
||||
@ -255,7 +255,7 @@ BPY_PROPDEF_DESC_DOC
|
||||
" :type options: set\n"
|
||||
" :arg subtype: Enumerator in ['COLOR', 'TRANSLATION', 'DIRECTION', 'VELOCITY', 'ACCELERATION', 'MATRIX', 'EULER', 'QUATERNION', 'AXISANGLE', 'XYZ', 'COLOR_GAMMA', 'LAYER', 'NONE'].\n"
|
||||
" :type subtype: string\n"
|
||||
" :arg size: Vector dimensions in [1, and " STRINGIFY(PYRNA_STACK_ARRAY) "].\n"
|
||||
" :arg size: Vector dimensions in [1, and " STRINGIFY(PYRNA_STACK_ARRAY) "].\n"
|
||||
" :type size: int\n"
|
||||
;
|
||||
static PyObject *BPy_BoolVectorProperty(PyObject *self, PyObject *args, PyObject *kw)
|
||||
@ -265,7 +265,7 @@ static PyObject *BPy_BoolVectorProperty(PyObject *self, PyObject *args, PyObject
|
||||
BPY_PROPDEF_HEAD(BoolVectorProperty)
|
||||
|
||||
if(srna) {
|
||||
static const char *kwlist[] = {"attr", "name", "description", "default", "options", "subtype", "size", NULL};
|
||||
static const char *kwlist[]= {"attr", "name", "description", "default", "options", "subtype", "size", NULL};
|
||||
const char *id=NULL, *name="", *description="";
|
||||
int id_len;
|
||||
int def[PYRNA_STACK_ARRAY]={0};
|
||||
@ -325,7 +325,7 @@ static PyObject *BPy_IntProperty(PyObject *self, PyObject *args, PyObject *kw)
|
||||
BPY_PROPDEF_HEAD(IntProperty)
|
||||
|
||||
if(srna) {
|
||||
static const char *kwlist[] = {"attr", "name", "description", "default", "min", "max", "soft_min", "soft_max", "step", "options", "subtype", NULL};
|
||||
static const char *kwlist[]= {"attr", "name", "description", "default", "min", "max", "soft_min", "soft_max", "step", "options", "subtype", NULL};
|
||||
const char *id=NULL, *name="", *description="";
|
||||
int id_len;
|
||||
int min=INT_MIN, max=INT_MAX, soft_min=INT_MIN, soft_max=INT_MAX, step=1, def=0;
|
||||
@ -368,7 +368,7 @@ BPY_PROPDEF_DESC_DOC
|
||||
" :type options: set\n"
|
||||
" :arg subtype: Enumerator in ['COLOR', 'TRANSLATION', 'DIRECTION', 'VELOCITY', 'ACCELERATION', 'MATRIX', 'EULER', 'QUATERNION', 'AXISANGLE', 'XYZ', 'COLOR_GAMMA', 'LAYER', 'NONE'].\n"
|
||||
" :type subtype: string\n"
|
||||
" :arg size: Vector dimensions in [1, and " STRINGIFY(PYRNA_STACK_ARRAY) "].\n"
|
||||
" :arg size: Vector dimensions in [1, and " STRINGIFY(PYRNA_STACK_ARRAY) "].\n"
|
||||
" :type size: int\n"
|
||||
;
|
||||
static PyObject *BPy_IntVectorProperty(PyObject *self, PyObject *args, PyObject *kw)
|
||||
@ -378,7 +378,7 @@ static PyObject *BPy_IntVectorProperty(PyObject *self, PyObject *args, PyObject
|
||||
BPY_PROPDEF_HEAD(IntVectorProperty)
|
||||
|
||||
if(srna) {
|
||||
static const char *kwlist[] = {"attr", "name", "description", "default", "min", "max", "soft_min", "soft_max", "step", "options", "subtype", "size", NULL};
|
||||
static const char *kwlist[]= {"attr", "name", "description", "default", "min", "max", "soft_min", "soft_max", "step", "options", "subtype", "size", NULL};
|
||||
const char *id=NULL, *name="", *description="";
|
||||
int id_len;
|
||||
int min=INT_MIN, max=INT_MAX, soft_min=INT_MIN, soft_max=INT_MAX, step=1, def[PYRNA_STACK_ARRAY]={0};
|
||||
@ -441,7 +441,7 @@ static PyObject *BPy_FloatProperty(PyObject *self, PyObject *args, PyObject *kw)
|
||||
BPY_PROPDEF_HEAD(FloatProperty)
|
||||
|
||||
if(srna) {
|
||||
static const char *kwlist[] = {"attr", "name", "description", "default", "min", "max", "soft_min", "soft_max", "step", "precision", "options", "subtype", "unit", NULL};
|
||||
static const char *kwlist[]= {"attr", "name", "description", "default", "min", "max", "soft_min", "soft_max", "step", "precision", "options", "subtype", "unit", NULL};
|
||||
const char *id=NULL, *name="", *description="";
|
||||
int id_len;
|
||||
float min=-FLT_MAX, max=FLT_MAX, soft_min=-FLT_MAX, soft_max=FLT_MAX, step=3, def=0.0f;
|
||||
@ -492,7 +492,7 @@ BPY_PROPDEF_DESC_DOC
|
||||
" :type options: set\n"
|
||||
" :arg subtype: Enumerator in ['COLOR', 'TRANSLATION', 'DIRECTION', 'VELOCITY', 'ACCELERATION', 'MATRIX', 'EULER', 'QUATERNION', 'AXISANGLE', 'XYZ', 'COLOR_GAMMA', 'LAYER', 'NONE'].\n"
|
||||
" :type subtype: string\n"
|
||||
" :arg size: Vector dimensions in [1, and " STRINGIFY(PYRNA_STACK_ARRAY) "].\n"
|
||||
" :arg size: Vector dimensions in [1, and " STRINGIFY(PYRNA_STACK_ARRAY) "].\n"
|
||||
" :type size: int\n"
|
||||
;
|
||||
static PyObject *BPy_FloatVectorProperty(PyObject *self, PyObject *args, PyObject *kw)
|
||||
@ -502,7 +502,7 @@ static PyObject *BPy_FloatVectorProperty(PyObject *self, PyObject *args, PyObjec
|
||||
BPY_PROPDEF_HEAD(FloatVectorProperty)
|
||||
|
||||
if(srna) {
|
||||
static const char *kwlist[] = {"attr", "name", "description", "default", "min", "max", "soft_min", "soft_max", "step", "precision", "options", "subtype", "size", NULL};
|
||||
static const char *kwlist[]= {"attr", "name", "description", "default", "min", "max", "soft_min", "soft_max", "step", "precision", "options", "subtype", "size", NULL};
|
||||
const char *id=NULL, *name="", *description="";
|
||||
int id_len;
|
||||
float min=-FLT_MAX, max=FLT_MAX, soft_min=-FLT_MAX, soft_max=FLT_MAX, step=3, def[PYRNA_STACK_ARRAY]={0.0f};
|
||||
@ -562,7 +562,7 @@ static PyObject *BPy_StringProperty(PyObject *self, PyObject *args, PyObject *kw
|
||||
BPY_PROPDEF_HEAD(StringProperty)
|
||||
|
||||
if(srna) {
|
||||
static const char *kwlist[] = {"attr", "name", "description", "default", "maxlen", "options", "subtype", NULL};
|
||||
static const char *kwlist[]= {"attr", "name", "description", "default", "maxlen", "options", "subtype", NULL};
|
||||
const char *id=NULL, *name="", *description="", *def="";
|
||||
int id_len;
|
||||
int maxlen=0;
|
||||
@ -703,7 +703,7 @@ static PyObject *BPy_EnumProperty(PyObject *self, PyObject *args, PyObject *kw)
|
||||
BPY_PROPDEF_HEAD(EnumProperty)
|
||||
|
||||
if(srna) {
|
||||
static const char *kwlist[] = {"attr", "items", "name", "description", "default", "options", NULL};
|
||||
static const char *kwlist[]= {"attr", "items", "name", "description", "default", "options", NULL};
|
||||
const char *id=NULL, *name="", *description="";
|
||||
PyObject *def= NULL;
|
||||
int id_len;
|
||||
@ -788,7 +788,7 @@ static PyObject *BPy_PointerProperty(PyObject *self, PyObject *args, PyObject *k
|
||||
BPY_PROPDEF_HEAD(PointerProperty)
|
||||
|
||||
if(srna) {
|
||||
static const char *kwlist[] = {"attr", "type", "name", "description", "options", NULL};
|
||||
static const char *kwlist[]= {"attr", "type", "name", "description", "options", NULL};
|
||||
const char *id=NULL, *name="", *description="";
|
||||
int id_len;
|
||||
PropertyRNA *prop;
|
||||
@ -835,7 +835,7 @@ static PyObject *BPy_CollectionProperty(PyObject *self, PyObject *args, PyObject
|
||||
BPY_PROPDEF_HEAD(CollectionProperty)
|
||||
|
||||
if(srna) {
|
||||
static const char *kwlist[] = {"attr", "type", "name", "description", "options", NULL};
|
||||
static const char *kwlist[]= {"attr", "type", "name", "description", "options", NULL};
|
||||
const char *id=NULL, *name="", *description="";
|
||||
int id_len;
|
||||
PropertyRNA *prop;
|
||||
@ -897,7 +897,7 @@ static PyObject *BPy_RemoveProperty(PyObject *self, PyObject *args, PyObject *kw
|
||||
return NULL;
|
||||
}
|
||||
else {
|
||||
static const char *kwlist[] = {"attr", NULL};
|
||||
static const char *kwlist[]= {"attr", NULL};
|
||||
|
||||
char *id=NULL;
|
||||
|
||||
@ -912,7 +912,7 @@ static PyObject *BPy_RemoveProperty(PyObject *self, PyObject *args, PyObject *kw
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
||||
static struct PyMethodDef props_methods[] = {
|
||||
static struct PyMethodDef props_methods[]= {
|
||||
{"BoolProperty", (PyCFunction)BPy_BoolProperty, METH_VARARGS|METH_KEYWORDS, BPy_BoolProperty_doc},
|
||||
{"BoolVectorProperty", (PyCFunction)BPy_BoolVectorProperty, METH_VARARGS|METH_KEYWORDS, BPy_BoolVectorProperty_doc},
|
||||
{"IntProperty", (PyCFunction)BPy_IntProperty, METH_VARARGS|METH_KEYWORDS, BPy_IntProperty_doc},
|
||||
@ -928,7 +928,7 @@ static struct PyMethodDef props_methods[] = {
|
||||
{NULL, NULL, 0, NULL}
|
||||
};
|
||||
|
||||
static struct PyModuleDef props_module = {
|
||||
static struct PyModuleDef props_module= {
|
||||
PyModuleDef_HEAD_INIT,
|
||||
"bpy.props",
|
||||
"This module defines properties to extend blenders internal data, the result of these functions"
|
||||
@ -954,7 +954,7 @@ PyObject *BPY_rna_props( void )
|
||||
/* api needs the PyObjects internally */
|
||||
submodule_dict= PyModule_GetDict(submodule);
|
||||
|
||||
#define ASSIGN_STATIC(_name) pymeth_##_name = PyDict_GetItemString(submodule_dict, #_name)
|
||||
#define ASSIGN_STATIC(_name) pymeth_##_name= PyDict_GetItemString(submodule_dict, #_name)
|
||||
|
||||
ASSIGN_STATIC(BoolProperty);
|
||||
ASSIGN_STATIC(BoolVectorProperty);
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -79,7 +79,7 @@ static int pyrna_struct_anim_args_parse(PointerRNA *ptr, const char *error_prefi
|
||||
}
|
||||
}
|
||||
else {
|
||||
prop = RNA_struct_find_property(ptr, path);
|
||||
prop= RNA_struct_find_property(ptr, path);
|
||||
r_ptr= *ptr;
|
||||
}
|
||||
|
||||
@ -126,17 +126,17 @@ static int pyrna_struct_anim_args_parse(PointerRNA *ptr, const char *error_prefi
|
||||
}
|
||||
|
||||
/* internal use for insert and delete */
|
||||
static int pyrna_struct_keyframe_parse(PointerRNA *ptr, PyObject *args, PyObject *kw, const char *parse_str, const char *error_prefix,
|
||||
static int pyrna_struct_keyframe_parse(PointerRNA *ptr, PyObject *args, PyObject *kw, const char *parse_str, const char *error_prefix,
|
||||
const char **path_full, int *index, float *cfra, const char **group_name) /* return values */
|
||||
{
|
||||
static const char *kwlist[] = {"data_path", "index", "frame", "group", NULL};
|
||||
static const char *kwlist[]= {"data_path", "index", "frame", "group", NULL};
|
||||
const char *path;
|
||||
|
||||
/* note, parse_str MUST start with 's|ifs' */
|
||||
if (!PyArg_ParseTupleAndKeywords(args, kw, parse_str, (char **)kwlist, &path, index, cfra, group_name))
|
||||
return -1;
|
||||
|
||||
if(pyrna_struct_anim_args_parse(ptr, error_prefix, path, path_full, index) < 0)
|
||||
if(pyrna_struct_anim_args_parse(ptr, error_prefix, path, path_full, index) < 0)
|
||||
return -1;
|
||||
|
||||
if(*cfra==FLT_MAX)
|
||||
@ -258,7 +258,7 @@ PyObject *pyrna_struct_driver_add(BPy_StructRNA *self, PyObject *args)
|
||||
if (!PyArg_ParseTuple(args, "s|i:driver_add", &path, &index))
|
||||
return NULL;
|
||||
|
||||
if(pyrna_struct_anim_args_parse(&self->ptr, "bpy_struct.driver_add():", path, &path_full, &index) < 0) {
|
||||
if(pyrna_struct_anim_args_parse(&self->ptr, "bpy_struct.driver_add():", path, &path_full, &index) < 0) {
|
||||
return NULL;
|
||||
}
|
||||
else {
|
||||
@ -332,7 +332,7 @@ PyObject *pyrna_struct_driver_remove(BPy_StructRNA *self, PyObject *args)
|
||||
if (!PyArg_ParseTuple(args, "s|i:driver_remove", &path, &index))
|
||||
return NULL;
|
||||
|
||||
if(pyrna_struct_anim_args_parse(&self->ptr, "bpy_struct.driver_remove():", path, &path_full, &index) < 0) {
|
||||
if(pyrna_struct_anim_args_parse(&self->ptr, "bpy_struct.driver_remove():", path, &path_full, &index) < 0) {
|
||||
return NULL;
|
||||
}
|
||||
else {
|
||||
|
@ -49,7 +49,7 @@ typedef void (*RNA_SetIndexFunc)(PointerRNA *, PropertyRNA *, int index, void *)
|
||||
*/
|
||||
|
||||
/*
|
||||
arr[2] = x
|
||||
arr[2]= x
|
||||
|
||||
py_to_array_index(arraydim=0, arrayoffset=0, index=2)
|
||||
validate_array(lvalue_dim=0)
|
||||
@ -187,16 +187,16 @@ static int validate_array_length(PyObject *rvalue, PointerRNA *ptr, PropertyRNA
|
||||
|
||||
/* arr[3][4][5]
|
||||
|
||||
arr[2] = x
|
||||
arr[2]= x
|
||||
dimsize={4, 5}
|
||||
dimsize[1] = 4
|
||||
dimsize[2] = 5
|
||||
dimsize[1]= 4
|
||||
dimsize[2]= 5
|
||||
lvalue_dim=0, totdim=3
|
||||
|
||||
arr[2][3] = x
|
||||
arr[2][3]= x
|
||||
lvalue_dim=1
|
||||
|
||||
arr[2][3][4] = x
|
||||
arr[2][3][4]= x
|
||||
lvalue_dim=2 */
|
||||
for (i= lvalue_dim; i < totdim; i++)
|
||||
len *= dimsize[i];
|
||||
@ -234,7 +234,7 @@ static char *copy_value_single(PyObject *item, PointerRNA *ptr, PropertyRNA *pro
|
||||
|
||||
convert_item(item, value);
|
||||
rna_set_index(ptr, prop, *index, value);
|
||||
*index = *index + 1;
|
||||
*index= *index + 1;
|
||||
}
|
||||
else {
|
||||
convert_item(item, data);
|
||||
@ -320,11 +320,11 @@ static int py_to_array_index(PyObject *py, PointerRNA *ptr, PropertyRNA *prop, i
|
||||
|
||||
/* arr[3][4][5]
|
||||
|
||||
arr[2] = x
|
||||
lvalue_dim=0, index = 0 + 2 * 4 * 5
|
||||
arr[2]= x
|
||||
lvalue_dim=0, index= 0 + 2 * 4 * 5
|
||||
|
||||
arr[2][3] = x
|
||||
lvalue_dim=1, index = 40 + 3 * 5 */
|
||||
arr[2][3]= x
|
||||
lvalue_dim=1, index= 40 + 3 * 5 */
|
||||
|
||||
lvalue_dim++;
|
||||
|
||||
@ -504,7 +504,7 @@ PyObject *pyrna_py_from_array_index(BPy_PropertyArrayRNA *self, PointerRNA *ptr,
|
||||
BPy_PropertyArrayRNA *ret= NULL;
|
||||
|
||||
arraydim= self ? self->arraydim : 0;
|
||||
arrayoffset = self ? self->arrayoffset : 0;
|
||||
arrayoffset= self ? self->arrayoffset : 0;
|
||||
|
||||
/* just in case check */
|
||||
len= RNA_property_multi_array_length(ptr, prop, arraydim);
|
||||
@ -524,11 +524,11 @@ PyObject *pyrna_py_from_array_index(BPy_PropertyArrayRNA *self, PointerRNA *ptr,
|
||||
|
||||
/* arr[3][4][5]
|
||||
|
||||
x = arr[2]
|
||||
index = 0 + 2 * 4 * 5
|
||||
x= arr[2]
|
||||
index= 0 + 2 * 4 * 5
|
||||
|
||||
x = arr[2][3]
|
||||
index = offset + 3 * 5 */
|
||||
x= arr[2][3]
|
||||
index= offset + 3 * 5 */
|
||||
|
||||
for (i= arraydim + 1; i < totdim; i++)
|
||||
index *= dimsize[i];
|
||||
@ -536,7 +536,7 @@ PyObject *pyrna_py_from_array_index(BPy_PropertyArrayRNA *self, PointerRNA *ptr,
|
||||
ret->arrayoffset= arrayoffset + index;
|
||||
}
|
||||
else {
|
||||
index = arrayoffset + index;
|
||||
index= arrayoffset + index;
|
||||
ret= (BPy_PropertyArrayRNA *)pyrna_array_index(ptr, prop, index);
|
||||
}
|
||||
|
||||
|
@ -57,7 +57,7 @@ static void cb_region_draw(const bContext *C, ARegion *UNUSED(ar), void *customd
|
||||
|
||||
cb_func= PyTuple_GET_ITEM((PyObject *)customdata, 0);
|
||||
cb_args= PyTuple_GET_ITEM((PyObject *)customdata, 1);
|
||||
result = PyObject_CallObject(cb_func, cb_args);
|
||||
result= PyObject_CallObject(cb_func, cb_args);
|
||||
|
||||
if(result) {
|
||||
Py_DECREF(result);
|
||||
@ -88,7 +88,7 @@ PyObject *pyrna_callback_add(BPy_StructRNA *self, PyObject *args)
|
||||
|
||||
if(RNA_struct_is_a(self->ptr.type, &RNA_Region)) {
|
||||
if(cb_event_str) {
|
||||
static EnumPropertyItem region_draw_mode_items[] = {
|
||||
static EnumPropertyItem region_draw_mode_items[]= {
|
||||
{REGION_DRAW_POST_PIXEL, "POST_PIXEL", 0, "Post Pixel", ""},
|
||||
{REGION_DRAW_POST_VIEW, "POST_VIEW", 0, "Post View", ""},
|
||||
{REGION_DRAW_PRE_VIEW, "PRE_VIEW", 0, "Pre View", ""},
|
||||
|
@ -77,7 +77,8 @@ parse_syntax_error(PyObject *err, PyObject **message, const char **filename,
|
||||
*offset = -1;
|
||||
Py_DECREF(v);
|
||||
v = NULL;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
hold = PyLong_AsLong(v);
|
||||
Py_DECREF(v);
|
||||
v = NULL;
|
||||
|
@ -37,7 +37,7 @@
|
||||
|
||||
#include "../generic/py_capi_utils.h"
|
||||
|
||||
static bContext* __py_context = NULL;
|
||||
static bContext* __py_context= NULL;
|
||||
bContext* BPy_GetContext(void) { return __py_context; }
|
||||
void BPy_SetContext(bContext *C) { __py_context= C; }
|
||||
|
||||
@ -52,7 +52,7 @@ char *BPy_enum_as_string(EnumPropertyItem *item)
|
||||
BLI_dynstr_appendf(dynstr, (e==item)?"'%s'":", '%s'", item->identifier);
|
||||
}
|
||||
|
||||
cstring = BLI_dynstr_get_cstring(dynstr);
|
||||
cstring= BLI_dynstr_get_cstring(dynstr);
|
||||
BLI_dynstr_free(dynstr);
|
||||
return cstring;
|
||||
}
|
||||
@ -146,19 +146,19 @@ int PyC_AsArray(void *array, PyObject *value, int length, PyTypeObject *type, co
|
||||
if(type == &PyFloat_Type) {
|
||||
float *array_float= array;
|
||||
for(i=0; i<length; i++) {
|
||||
array_float[i] = PyFloat_AsDouble(PySequence_Fast_GET_ITEM(value_fast, i));
|
||||
array_float[i]= PyFloat_AsDouble(PySequence_Fast_GET_ITEM(value_fast, i));
|
||||
}
|
||||
}
|
||||
else if(type == &PyLong_Type) {
|
||||
int *array_int= array;
|
||||
for(i=0; i<length; i++) {
|
||||
array_int[i] = PyLong_AsSsize_t(PySequence_Fast_GET_ITEM(value_fast, i));
|
||||
array_int[i]= PyLong_AsSsize_t(PySequence_Fast_GET_ITEM(value_fast, i));
|
||||
}
|
||||
}
|
||||
else if(type == &PyBool_Type) {
|
||||
int *array_bool= array;
|
||||
for(i=0; i<length; i++) {
|
||||
array_bool[i] = (PyLong_AsSsize_t(PySequence_Fast_GET_ITEM(value_fast, i)) != 0);
|
||||
array_bool[i]= (PyLong_AsSsize_t(PySequence_Fast_GET_ITEM(value_fast, i)) != 0);
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
Loading…
Reference in New Issue
Block a user