griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Merged changes in the trunk up to revision 38543.

Browse Source 
Conflicts resolved:
doc/python_api/sphinx_doc_gen.py
source/blender/blenkernel/CMakeLists.txt
source/blender/makesdna/DNA_material_types.h
source/blender/render/intern/source/pipeline.c
source/creator/CMakeLists.txt
This commit is contained in:
Tamito Kajiyama
2011-07-20 23:33:10 +00:00
parent 4c3140004a 76e91d7a5f
commit ce03ec4b86
395 changed files with 34491 additions and 33122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
source/blender/python/CMakeLists.txt
View File

@@ -18,3 +18,4 @@
add_subdirectory(intern)
add_subdirectory(generic)
add_subdirectory(mathutils)

11
source/blender/python/SConscript
View File

@@ -1,6 +1,6 @@
#!/usr/bin/python
# TODO, split into 2 files.
# TODO, split into 3 files.
Import ('env')
@@ -19,7 +19,14 @@ if is_debug:
defs.append('_DEBUG')
sources = env.Glob('generic/*.c')
env.BlenderLib( libname = 'bf_python_ext', sources = Split(sources), includes = Split(incs), defines = defs, libtype = ['core','player'], priority = [362,165]) # ketsji is 360
env.BlenderLib( libname = 'bf_python_ext', sources = Split(sources), includes = Split(incs), defines = defs, libtype = ['core','player'], priority = [363,165]) # ketsji is 360
# mathutils
defs = []
sources = env.Glob('mathutils/*.c')
env.BlenderLib( libname = 'bf_python_mathutils', sources = Split(sources), includes = Split(incs), defines = defs, libtype = ['core','player'], priority = [362,165])
# bpy

18
source/blender/python/generic/CMakeLists.txt
View File

@@ -20,10 +20,10 @@
set(INC
.
../../blenlib
../../makesdna
../../blenkernel
../../blenlib
../../blenloader
../../makesdna
../../../../intern/guardedalloc
)
@@ -37,13 +37,6 @@ set(SRC
bgl.c
blf_py_api.c
bpy_internal_import.c
mathutils.c
mathutils_Color.c
mathutils_Euler.c
mathutils_Matrix.c
mathutils_Quaternion.c
mathutils_Vector.c
mathutils_geometry.c
noise_py_api.c
py_capi_utils.c
@@ -51,13 +44,6 @@ set(SRC
bgl.h
blf_py_api.h
bpy_internal_import.h
mathutils.h
mathutils_Color.h
mathutils_Euler.h
mathutils_Matrix.h
mathutils_Quaternion.h
mathutils_Vector.h
mathutils_geometry.h
noise_py_api.h
py_capi_utils.h
)

539
source/blender/python/generic/bgl.c
View File

@@ -44,69 +44,179 @@
#include "BLI_utildefines.h"
PyDoc_STRVAR(Method_Buffer_doc,
"(type, dimensions, [template]) - Create a new Buffer object\n\n\
(type) - The format to store data in\n\
(dimensions) - An int or sequence specifying the dimensions of the buffer\n\
[template] - A sequence of matching dimensions to the buffer to be created\n\
which will be used to initialize the Buffer.\n\n\
If a template is not passed in all fields will be initialized to 0.\n\n\
The type should be one of GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE.\n\
If the dimensions are specified as an int a linear buffer will be\n\
created. If a sequence is passed for the dimensions the buffer\n\
will have len(sequence) dimensions, where the size for each dimension\n\
is determined by the value in the sequence at that index.\n\n\
For example, passing [100, 100] will create a 2 dimensional\n\
square buffer. Passing [16, 16, 32] will create a 3 dimensional\n\
buffer which is twice as deep as it is wide or high."
);
static PyObject *Method_Buffer(PyObject *self, PyObject *args);
static PyObject *Buffer_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
/* Buffer sequence methods */
static int Buffer_len(PyObject *self);
static PyObject *Buffer_item(PyObject *self, int i);
static PyObject *Buffer_slice(PyObject *self, int begin, int end);
static int Buffer_ass_item(PyObject *self, int i, PyObject *v);
static int Buffer_ass_slice(PyObject *self, int begin, int end,
PyObject *seq);
static int Buffer_len(Buffer *self);
static PyObject *Buffer_item(Buffer *self, int i);
static PyObject *Buffer_slice(Buffer *self, int begin, int end);
static int Buffer_ass_item(Buffer *self, int i, PyObject *v);
static int Buffer_ass_slice(Buffer *self, int begin, int end,
PyObject *seq);
static PyObject *Buffer_subscript(Buffer *self, PyObject *item);
static int Buffer_ass_subscript(Buffer *self, PyObject *item,
PyObject *value);
static PySequenceMethods Buffer_SeqMethods = {
( lenfunc ) Buffer_len, /*sq_length */
( binaryfunc ) NULL, /*sq_concat */
( ssizeargfunc ) NULL, /*sq_repeat */
( ssizeargfunc ) Buffer_item, /*sq_item */
( ssizessizeargfunc ) Buffer_slice, /*sq_slice, deprecated TODO, replace */
( ssizeobjargproc ) Buffer_ass_item, /*sq_ass_item */
( ssizessizeobjargproc ) Buffer_ass_slice, /*sq_ass_slice, deprecated TODO, replace */
(lenfunc) Buffer_len, /*sq_length */
(binaryfunc) NULL, /*sq_concat */
(ssizeargfunc) NULL, /*sq_repeat */
(ssizeargfunc) Buffer_item, /*sq_item */
(ssizessizeargfunc) Buffer_slice, /*sq_slice, deprecated TODO, replace */
(ssizeobjargproc) Buffer_ass_item, /*sq_ass_item */
(ssizessizeobjargproc) Buffer_ass_slice, /*sq_ass_slice, deprecated TODO, replace */
(objobjproc) NULL, /* sq_contains */
(binaryfunc) NULL, /* sq_inplace_concat */
(ssizeargfunc) NULL, /* sq_inplace_repeat */
};
static void Buffer_dealloc(PyObject *self);
static PyObject *Buffer_tolist(PyObject *self);
static PyObject *Buffer_dimensions(PyObject *self);
static PyObject *Buffer_getattr(PyObject *self, char *name);
static PyObject *Buffer_repr(PyObject *self);
static PyMappingMethods Buffer_AsMapping = {
(lenfunc)Buffer_len,
(binaryfunc)Buffer_subscript,
(objobjargproc)Buffer_ass_subscript
};
static void Buffer_dealloc(Buffer *self);
static PyObject *Buffer_repr(Buffer *self);
static PyObject *Buffer_to_list(Buffer *self)
{
int i, len= self->dimensions[0];
PyObject *list= PyList_New(len);
for (i=0; i<len; i++) {
PyList_SET_ITEM(list, i, Buffer_item(self, i));
}
return list;
}
static PyObject *Buffer_to_list_recursive(Buffer *self)
{
PyObject *list;
if(self->ndimensions > 1) {
int i, len= self->dimensions[0];
list= PyList_New(len);
for (i=0; i<len; i++) {
Buffer *sub= (Buffer *)Buffer_item(self, i);
PyList_SET_ITEM(list, i, Buffer_to_list_recursive(sub));
Py_DECREF(sub);
}
}
else {
list= Buffer_to_list(self);
}
return list;
}
/* *DEPRECATED* 2011/7/17 bgl.Buffer.list */
static PyObject *Buffer_list(Buffer *self, void *UNUSED(arg))
{
fprintf(stderr, "Warning: 'Buffer.list' deprecated, use '[:]' instead\n");
return Buffer_to_list(self);
}
static PyObject *Buffer_dimensions(Buffer *self, void *UNUSED(arg))
{
PyObject *list= PyList_New(self->ndimensions);
int i;
for (i= 0; i<self->ndimensions; i++) {
PyList_SET_ITEM(list, i, PyLong_FromLong(self->dimensions[i]));
}
return list;
}
static PyMethodDef Buffer_methods[] = {
{"to_list", (PyCFunction)Buffer_to_list_recursive, METH_NOARGS,
"return the buffer as a list"},
{NULL, NULL, 0, NULL}
};
static PyGetSetDef Buffer_getseters[] = {
{(char *)"list", (getter)Buffer_list, NULL, NULL, NULL},
{(char *)"dimensions", (getter)Buffer_dimensions, NULL, NULL, NULL},
{NULL, NULL, NULL, NULL, NULL}
};
PyTypeObject BGL_bufferType = {
PyVarObject_HEAD_INIT(NULL, 0)
"buffer", /*tp_name */
sizeof( Buffer ), /*tp_basicsize */
0, /*tp_itemsize */
( destructor ) Buffer_dealloc, /*tp_dealloc */
( printfunc ) 0, /*tp_print */
( getattrfunc ) Buffer_getattr, /*tp_getattr */
( setattrfunc ) 0, /*tp_setattr */
"bgl.Buffer", /*tp_name */
sizeof(Buffer), /*tp_basicsize */
0, /*tp_itemsize */
(destructor)Buffer_dealloc, /*tp_dealloc */
(printfunc)NULL, /*tp_print */
NULL, /*tp_getattr */
NULL, /*tp_setattr */
NULL, /*tp_compare */
( reprfunc ) Buffer_repr, /*tp_repr */
(reprfunc) Buffer_repr, /*tp_repr */
NULL, /*tp_as_number */
&Buffer_SeqMethods, /*tp_as_sequence */
&Buffer_AsMapping, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
Buffer_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
Buffer_getseters, /* struct PyGetSetDef *tp_getset; */
NULL, /*tp_base*/
NULL, /*tp_dict*/
NULL, /*tp_descr_get*/
NULL, /*tp_descr_set*/
0, /*tp_dictoffset*/
NULL, /*tp_init*/
NULL, /*tp_alloc*/
Buffer_new, /*tp_new*/
NULL, /*tp_free*/
NULL, /*tp_is_gc*/
NULL, /*tp_bases*/
NULL, /*tp_mro*/
NULL, /*tp_cache*/
NULL, /*tp_subclasses*/
NULL, /*tp_weaklist*/
NULL /*tp_del*/
};
/* #ifndef __APPLE__ */
#define BGL_Wrap(nargs, funcname, ret, arg_list) \
@@ -174,26 +284,13 @@ Buffer *BGL_MakeBuffer(int type, int ndimensions, int *dimensions, void *initbuf
}
else {
memset(buffer->buf.asvoid, 0, length*size);
/*
for (i= 0; i<length; i++) {
if (type==GL_BYTE)
buffer->buf.asbyte[i]= 0;
else if (type==GL_SHORT)
buffer->buf.asshort[i]= 0;
else if (type==GL_INT)
buffer->buf.asint[i]= 0;
else if (type==GL_FLOAT)
buffer->buf.asfloat[i]= 0.0f;
else if (type==GL_DOUBLE)
buffer->buf.asdouble[i]= 0.0;
}
*/
}
return buffer;
}
#define MAX_DIMENSIONS 256
static PyObject *Method_Buffer (PyObject *UNUSED(self), PyObject *args)
static PyObject *Buffer_new(PyTypeObject *UNUSED(type), PyObject *args, PyObject *kwds)
{
PyObject *length_ob= NULL, *init= NULL;
Buffer *buffer;
@@ -201,31 +298,41 @@ static PyObject *Method_Buffer (PyObject *UNUSED(self), PyObject *args)
int i, type;
int ndimensions = 0;
if (!PyArg_ParseTuple(args, "iO|O", &type, &length_ob, &init)) {
PyErr_SetString(PyExc_AttributeError, "expected an int and one or two PyObjects");
if(kwds && PyDict_Size(kwds)) {
PyErr_SetString(PyExc_TypeError,
"bgl.Buffer(): takes no keyword args");
return NULL;
}
if (!PyArg_ParseTuple(args, "iO|O: bgl.Buffer", &type, &length_ob, &init)) {
return NULL;
}
if (!ELEM5(type, GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, GL_DOUBLE)) {
PyErr_SetString(PyExc_AttributeError, "invalid first argument type, should be one of GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT or GL_DOUBLE");
PyErr_SetString(PyExc_AttributeError,
"invalid first argument type, should be one of "
"GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT or GL_DOUBLE");
return NULL;
}
if (PyLong_Check(length_ob)) {
ndimensions= 1;
if(((dimensions[0]= PyLong_AsLong(length_ob)) < 1)) {
PyErr_SetString(PyExc_AttributeError, "dimensions must be between 1 and "STRINGIFY(MAX_DIMENSIONS));
PyErr_SetString(PyExc_AttributeError,
"dimensions must be between 1 and "STRINGIFY(MAX_DIMENSIONS));
return NULL;
}
}
else if (PySequence_Check(length_ob)) {
ndimensions= PySequence_Size(length_ob);
if (ndimensions > MAX_DIMENSIONS) {
PyErr_SetString(PyExc_AttributeError, "too many dimensions, max is "STRINGIFY(MAX_DIMENSIONS));
PyErr_SetString(PyExc_AttributeError,
"too many dimensions, max is "STRINGIFY(MAX_DIMENSIONS));
return NULL;
}
else if (ndimensions < 1) {
PyErr_SetString(PyExc_AttributeError, "sequence must have at least one dimension");
PyErr_SetString(PyExc_AttributeError,
"sequence must have at least one dimension");
return NULL;
}
for (i=0; i<ndimensions; i++) {
@@ -236,19 +343,22 @@ static PyObject *Method_Buffer (PyObject *UNUSED(self), PyObject *args)
Py_DECREF(ob);
if(dimensions[i] < 1) {
PyErr_SetString(PyExc_AttributeError, "dimensions must be between 1 and "STRINGIFY(MAX_DIMENSIONS));
PyErr_SetString(PyExc_AttributeError,
"dimensions must be between 1 and "STRINGIFY(MAX_DIMENSIONS));
return NULL;
}
}
}
else {
PyErr_Format(PyExc_TypeError, "invalid second argument argument expected a sequence or an int, not a %.200s", Py_TYPE(length_ob)->tp_name);
PyErr_Format(PyExc_TypeError,
"invalid second argument argument expected a sequence "
"or an int, not a %.200s", Py_TYPE(length_ob)->tp_name);
return NULL;
}
buffer= BGL_MakeBuffer(type, ndimensions, dimensions, NULL);
if (init && ndimensions) {
if (Buffer_ass_slice((PyObject *) buffer, 0, dimensions[0], init)) {
if (Buffer_ass_slice(buffer, 0, dimensions[0], init)) {
Py_DECREF(buffer);
return NULL;
}
@@ -259,51 +369,48 @@ static PyObject *Method_Buffer (PyObject *UNUSED(self), PyObject *args)
/*@ Buffer sequence methods */
static int Buffer_len(PyObject *self)
static int Buffer_len(Buffer *self)
{
Buffer *buf= (Buffer *) self;
return buf->dimensions[0];
return self->dimensions[0];
}
static PyObject *Buffer_item(PyObject *self, int i)
static PyObject *Buffer_item(Buffer *self, int i)
{
Buffer *buf= (Buffer *) self;
if (i >= buf->dimensions[0]) {
if (i >= self->dimensions[0] || i < 0) {
PyErr_SetString(PyExc_IndexError, "array index out of range");
return NULL;
}
if (buf->ndimensions==1) {
switch (buf->type) {
case GL_BYTE: return Py_BuildValue("b", buf->buf.asbyte[i]);
case GL_SHORT: return Py_BuildValue("h", buf->buf.asshort[i]);
case GL_INT: return Py_BuildValue("i", buf->buf.asint[i]);
case GL_FLOAT: return PyFloat_FromDouble(buf->buf.asfloat[i]);
case GL_DOUBLE: return Py_BuildValue("d", buf->buf.asdouble[i]);
if (self->ndimensions==1) {
switch (self->type) {
case GL_BYTE: return Py_BuildValue("b", self->buf.asbyte[i]);
case GL_SHORT: return Py_BuildValue("h", self->buf.asshort[i]);
case GL_INT: return Py_BuildValue("i", self->buf.asint[i]);
case GL_FLOAT: return PyFloat_FromDouble(self->buf.asfloat[i]);
case GL_DOUBLE: return Py_BuildValue("d", self->buf.asdouble[i]);
}
}
else {
Buffer *newbuf;
int j, length, size;
length= 1;
for (j=1; j<buf->ndimensions; j++) {
length*= buf->dimensions[j];
for (j=1; j < self->ndimensions; j++) {
length *= self->dimensions[j];
}
size= BGL_typeSize(buf->type);
size= BGL_typeSize(self->type);
newbuf= (Buffer *) PyObject_NEW(Buffer, &BGL_bufferType);
Py_INCREF(self);
newbuf->parent= self;
newbuf->parent= (PyObject *)self;
newbuf->ndimensions= buf->ndimensions-1;
newbuf->type= buf->type;
newbuf->buf.asvoid= buf->buf.asbyte + i*length*size;
newbuf->ndimensions= self->ndimensions - 1;
newbuf->type= self->type;
newbuf->buf.asvoid= self->buf.asbyte + i*length*size;
newbuf->dimensions= MEM_mallocN(newbuf->ndimensions*sizeof(int),
"Buffer dimensions");
memcpy(newbuf->dimensions, buf->dimensions+1,
memcpy(newbuf->dimensions, self->dimensions+1,
newbuf->ndimensions*sizeof(int));
return (PyObject *) newbuf;
@@ -312,16 +419,14 @@ static PyObject *Buffer_item(PyObject *self, int i)
return NULL;
}
static PyObject *Buffer_slice(PyObject *self, int begin, int end)
static PyObject *Buffer_slice(Buffer *self, int begin, int end)
{
Buffer *buf= (Buffer *) self;
PyObject *list;
int count;
if (begin<0) begin= 0;
if (end>buf->dimensions[0])
end= buf->dimensions[0];
if (begin>end) begin= end;
if (begin < 0) begin= 0;
if (end > self->dimensions[0]) end= self->dimensions[0];
if (begin > end) begin= end;
list= PyList_New(end-begin);
@@ -331,134 +436,180 @@ static PyObject *Buffer_slice(PyObject *self, int begin, int end)
return list;
}
static int Buffer_ass_item(PyObject *self, int i, PyObject *v)
static int Buffer_ass_item(Buffer *self, int i, PyObject *v)
{
Buffer *buf= (Buffer *) self;
if (i >= buf->dimensions[0]) {
PyErr_SetString(PyExc_IndexError, "array assignment index out of range");
if (i >= self->dimensions[0] || i < 0) {
PyErr_SetString(PyExc_IndexError,
"array assignment index out of range");
return -1;
}
if (buf->ndimensions!=1) {
PyObject *row= Buffer_item(self, i);
int ret;
if (!row) return -1;
ret= Buffer_ass_slice(row, 0, buf->dimensions[1], v);
Py_DECREF(row);
return ret;
if (self->ndimensions!=1) {
Buffer *row= (Buffer *)Buffer_item(self, i);
if (row) {
int ret= Buffer_ass_slice(row, 0, self->dimensions[1], v);
Py_DECREF(row);
return ret;
}
else {
return -1;
}
}
if (buf->type==GL_BYTE) {
if (!PyArg_Parse(v, "b:Coordinates must be ints", &buf->buf.asbyte[i]))
return -1;
switch(self->type) {
case GL_BYTE:
return PyArg_Parse(v, "b:Expected ints", &self->buf.asbyte[i]) ? 0:-1;
case GL_SHORT:
return PyArg_Parse(v, "h:Expected ints", &self->buf.asshort[i]) ? 0:-1;
case GL_INT:
return PyArg_Parse(v, "i:Expected ints", &self->buf.asint[i]) ? 0:-1;
case GL_FLOAT:
return PyArg_Parse(v, "f:Expected floats", &self->buf.asfloat[i]) ? 0:-1;
case GL_DOUBLE:
return PyArg_Parse(v, "d:Expected floats", &self->buf.asdouble[i]) ? 0:-1;
default:
return 0; /* should never happen */
}
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) {
if (!PyArg_Parse(v, "i:Coordinates must be ints", &buf->buf.asint[i]))
return -1;
}
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) {
if (!PyArg_Parse(v, "d:Coordinates must be floats", &buf->buf.asdouble[i]))
return -1;
}
return 0;
}
static int Buffer_ass_slice(PyObject *self, int begin, int end, PyObject *seq)
static int Buffer_ass_slice(Buffer *self, int begin, int end, PyObject *seq)
{
Buffer *buf= (Buffer *) self;
PyObject *item;
int count, err=0;
if (begin<0) begin= 0;
if (end>buf->dimensions[0]) end= buf->dimensions[0];
if (begin>end) begin= end;
if (begin < 0) begin= 0;
if (end > self->dimensions[0]) end= self->dimensions[0];
if (begin > end) begin= end;
if (!PySequence_Check(seq)) {
PyErr_SetString(PyExc_TypeError,
"illegal argument type for built-in operation");
PyErr_Format(PyExc_TypeError,
"buffer[:] = value, invalid assignment. "
"Expected a sequence, not an %.200s type",
Py_TYPE(seq)->tp_name);
return -1;
}
if (PySequence_Size(seq)!=(end-begin)) {
int seq_len = PySequence_Size(seq);
char err_str[128];
sprintf(err_str, "size mismatch in assignment. Expected size: %d (size provided: %d)", seq_len, (end-begin));
PyErr_SetString(PyExc_TypeError, err_str);
/* re-use count var */
if ((count= PySequence_Size(seq)) != (end - begin)) {
PyErr_Format(PyExc_TypeError,
"buffer[:] = value, size mismatch in assignment. "
"Expected: %d (given: %d)", count, end - begin);
return -1;
}
for (count= begin; count<end; count++) {
item= PySequence_GetItem(seq, count-begin);
err= Buffer_ass_item(self, count, item);
Py_DECREF(item);
for (count= begin; count < end; count++) {
item= PySequence_GetItem(seq, count - begin);
if(item) {
err= Buffer_ass_item(self, count, item);
Py_DECREF(item);
}
else {
err= -1;
}
if (err) break;
}
return err;
}
static void Buffer_dealloc(PyObject *self)
static PyObject *Buffer_subscript(Buffer *self, PyObject *item)
{
Buffer *buf = (Buffer *)self;
if (PyIndex_Check(item)) {
Py_ssize_t i;
i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
if (i < 0)
i += self->dimensions[0];
return Buffer_item(self, i);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength;
if (buf->parent) Py_DECREF (buf->parent);
else MEM_freeN (buf->buf.asvoid);
if (PySlice_GetIndicesEx((void *)item, self->dimensions[0], &start, &stop, &step, &slicelength) < 0)
return NULL;
MEM_freeN (buf->dimensions);
PyObject_DEL (self);
if (slicelength <= 0) {
return PyTuple_New(0);
}
else if (step == 1) {
return Buffer_slice(self, start, stop);
}
else {
PyErr_SetString(PyExc_IndexError,
"slice steps not supported with vectors");
return NULL;
}
}
else {
PyErr_Format(PyExc_TypeError,
"buffer indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return NULL;
}
}
static PyObject *Buffer_tolist(PyObject *self)
static int Buffer_ass_subscript(Buffer *self, PyObject *item, PyObject *value)
{
int i, len= ((Buffer *)self)->dimensions[0];
PyObject *list= PyList_New(len);
if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return -1;
if (i < 0)
i += self->dimensions[0];
return Buffer_ass_item(self, i, value);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength;
for (i=0; i<len; i++) {
PyList_SET_ITEM(list, i, Buffer_item(self, i));
if (PySlice_GetIndicesEx((void *)item, self->dimensions[0], &start, &stop, &step, &slicelength) < 0)
return -1;
if (step == 1)
return Buffer_ass_slice(self, start, stop, value);
else {
PyErr_SetString(PyExc_IndexError,
"slice steps not supported with vectors");
return -1;
}
}
else {
PyErr_Format(PyExc_TypeError,
"buffer indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return -1;
}
}
static void Buffer_dealloc(Buffer *self)
{
if (self->parent) Py_DECREF(self->parent);
else MEM_freeN (self->buf.asvoid);
MEM_freeN(self->dimensions);
PyObject_DEL(self);
}
static PyObject *Buffer_repr(Buffer *self)
{
PyObject *list= Buffer_to_list_recursive(self);
PyObject *repr;
const char *typestr= "UNKNOWN";
switch(self->type) {
case GL_BYTE: typestr= "GL_BYTE"; break;
case GL_SHORT: typestr= "GL_SHORT"; break;
case GL_INT: typestr= "GL_BYTE"; break;
case GL_FLOAT: typestr= "GL_FLOAT"; break;
case GL_DOUBLE: typestr= "GL_DOUBLE"; break;
}
return list;
}
static PyObject *Buffer_dimensions(PyObject *self)
{
Buffer *buffer= (Buffer *) self;
PyObject *list= PyList_New(buffer->ndimensions);
int i;
for (i= 0; i<buffer->ndimensions; i++) {
PyList_SET_ITEM(list, i, PyLong_FromLong(buffer->dimensions[i]));
}
return list;
}
static PyObject *Buffer_getattr(PyObject *self, char *name)
{
if (strcmp(name, "list")==0) return Buffer_tolist(self);
else if (strcmp(name, "dimensions")==0) return Buffer_dimensions(self);
PyErr_SetString(PyExc_AttributeError, name);
return NULL;
}
static PyObject *Buffer_repr(PyObject *self)
{
PyObject *list= Buffer_tolist(self);
PyObject *repr= PyObject_Repr(list);
repr= PyUnicode_FromFormat("Buffer(%s, %R)", typestr, list);
Py_DECREF(list);
return repr;
}
@@ -805,7 +956,6 @@ BGLU_Wrap(9, UnProject, GLint, (GLdouble, GLdouble, GLdouble, GLdoubleP, GLdo
* {"glAccum", Method_Accumfunc, METH_VARARGS} */
static struct PyMethodDef BGL_methods[] = {
{"Buffer", Method_Buffer, METH_VARARGS, Method_Buffer_doc},
/* #ifndef __APPLE__ */
MethodDef(Accum),
@@ -1153,9 +1303,12 @@ PyObject *BPyInit_bgl(void)
submodule= PyModule_Create(&BGL_module_def);
dict= PyModule_GetDict(submodule);
if( PyType_Ready( &BGL_bufferType) < 0)
if(PyType_Ready(&BGL_bufferType) < 0)
return NULL; /* should never happen */
PyModule_AddObject(submodule, "Buffer", (PyObject *)&BGL_bufferType);
#define EXPP_ADDCONST(x) PyDict_SetItemString(dict, #x, item=PyLong_FromLong((int)x)); Py_DECREF(item)
/* So, for example:

2
source/blender/python/generic/py_capi_utils.c
View File

@@ -36,8 +36,6 @@
#include "BLI_path_util.h"
#endif
#define PYC_INTERPRETER_ACTIVE (((PyThreadState*)_Py_atomic_load_relaxed(&_PyThreadState_Current)) != NULL)
/* array utility function */
int PyC_AsArray(void *array, PyObject *value, const int length, const PyTypeObject *type, const short is_double, const char *error_prefix)
{

2
source/blender/python/generic/py_capi_utils.h
View File

@@ -50,4 +50,6 @@ void PyC_MainModule_Restore(PyObject *main_mod);
void PyC_SetHomePath(const char *py_path_bundle);
#define PYC_INTERPRETER_ACTIVE (((PyThreadState*)_Py_atomic_load_relaxed(&_PyThreadState_Current)) != NULL)
#endif // PY_CAPI_UTILS_H

9
source/blender/python/intern/CMakeLists.txt
View File

@@ -25,13 +25,13 @@
set(INC
..
../../blenkernel
../../blenlib
../../blenloader
../../editors/include
../../makesdna
../../makesrna
../../blenkernel
../../blenloader
../../windowmanager
../../editors/include
../../freestyle/intern/python
../../../../intern/guardedalloc
)
@@ -89,9 +89,6 @@ if(WITH_PYTHON_SAFETY)
endif()
if(WITH_AUDASPACE)
list(APPEND INC
../../../intern/audaspace/intern
)
add_definitions(-DWITH_AUDASPACE)
endif()

4
source/blender/python/intern/bpy.c
View File

@@ -55,10 +55,10 @@
#include "MEM_guardedalloc.h"
/* external util modules */
#include "../generic/mathutils.h"
#include "../generic/IDProp.h"
#include "../generic/bgl.h"
#include "../generic/blf_py_api.h"
#include "../generic/IDProp.h"
#include "../mathutils/mathutils.h"
#include "BPy_Freestyle.h"

8
source/blender/python/intern/bpy_driver.c
View File

@@ -41,6 +41,8 @@
#include "bpy_driver.h"
#include "../generic/py_capi_utils.h"
/* for pydrivers (drivers using one-line Python expressions to express relationships between targets) */
PyObject *bpy_pydriver_Dict= NULL;
@@ -87,7 +89,7 @@ int bpy_pydriver_create_dict(void)
void BPY_driver_reset(void)
{
PyGILState_STATE gilstate;
int use_gil= 1; // (PyThreadState_Get()==NULL);
int use_gil= !PYC_INTERPRETER_ACTIVE;
if(use_gil)
gilstate= PyGILState_Ensure();
@@ -120,7 +122,7 @@ static void pydriver_error(ChannelDriver *driver)
*
* note: PyGILState_Ensure() isnt always called because python can call the
* bake operator which intern starts a thread which calls scene update which
* does a driver update. to avoid a deadlock check PyThreadState_Get() if PyGILState_Ensure() is needed.
* does a driver update. to avoid a deadlock check PYC_INTERPRETER_ACTIVE if PyGILState_Ensure() is needed.
*/
float BPY_driver_exec(ChannelDriver *driver)
{
@@ -147,7 +149,7 @@ float BPY_driver_exec(ChannelDriver *driver)
return 0.0f;
}
use_gil= 1; //(PyThreadState_Get()==NULL);
use_gil= !PYC_INTERPRETER_ACTIVE;
if(use_gil)
gilstate= PyGILState_Ensure();

27
source/blender/python/intern/bpy_interface.c
View File

@@ -66,10 +66,10 @@
#include "../generic/py_capi_utils.h"
/* inittab initialization functions */
#include "../generic/noise_py_api.h"
#include "../generic/mathutils.h"
#include "../generic/bgl.h"
#include "../generic/blf_py_api.h"
#include "../generic/noise_py_api.h"
#include "../mathutils/mathutils.h"
/* for internal use, when starting and ending python scripts */
@@ -175,8 +175,8 @@ extern PyObject *AUD_initPython(void);
static struct _inittab bpy_internal_modules[]= {
{(char *)"noise", BPyInit_noise},
{(char *)"mathutils", BPyInit_mathutils},
// {(char *)"mathutils.geometry", BPyInit_mathutils_geometry},
{(char *)"mathutils", PyInit_mathutils},
// {(char *)"mathutils.geometry", PyInit_mathutils_geometry},
{(char *)"bgl", BPyInit_bgl},
{(char *)"blf", BPyInit_blf},
#ifdef WITH_AUDASPACE
@@ -209,8 +209,6 @@ void BPY_python_start(int argc, const char **argv)
Py_Initialize();
bpy_intern_string_init();
// PySys_SetArgv(argc, argv); // broken in py3, not a huge deal
/* sigh, why do python guys not have a char** version anymore? :( */
{
@@ -233,6 +231,8 @@ void BPY_python_start(int argc, const char **argv)
PyImport_ExtendInittab(bpy_internal_modules);
#endif
bpy_intern_string_init();
/* bpy.* and lets us import it */
BPy_init_modules();
@@ -663,7 +663,9 @@ int BPY_context_member_get(bContext *C, const char *member, bContextDataResult *
#include "BLI_storage.h"
/* TODO, reloading the module isnt functional at the moment. */
extern int main_python(int argc, const char **argv);
static void bpy_module_free(void *mod);
extern int main_python_enter(int argc, const char **argv);
extern void main_python_exit(void);
static struct PyModuleDef bpy_proxy_def= {
PyModuleDef_HEAD_INIT,
"bpy", /* m_name */
@@ -673,8 +675,8 @@ static struct PyModuleDef bpy_proxy_def= {
NULL, /* m_reload */
NULL, /* m_traverse */
NULL, /* m_clear */
NULL, /* m_free */
};
bpy_module_free, /* m_free */
};
typedef struct {
PyObject_HEAD
@@ -699,7 +701,7 @@ void bpy_module_delay_init(PyObject *bpy_proxy)
// printf("module found %s\n", argv[0]);
main_python(argc, argv);
main_python_enter(argc, argv);
/* initialized in BPy_init_modules() */
PyDict_Update(PyModule_GetDict(bpy_proxy), PyModule_GetDict(bpy_package_py));
@@ -756,4 +758,9 @@ PyInit_bpy(void)
return bpy_proxy;
}
static void bpy_module_free(void *UNUSED(mod))
{
main_python_exit();
}
#endif

8
source/blender/python/intern/bpy_rna.c
View File

@@ -346,7 +346,7 @@ static int pyrna_py_to_prop(PointerRNA *ptr, PropertyRNA *prop, void *data, PyOb
static int deferred_register_prop(StructRNA *srna, PyObject *key, PyObject *item);
#ifdef USE_MATHUTILS
#include "../generic/mathutils.h" /* so we can have mathutils callbacks */
#include "../mathutils/mathutils.h" /* so we can have mathutils callbacks */
static PyObject *pyrna_prop_array_subscript_slice(BPy_PropertyArrayRNA *self, PointerRNA *ptr, PropertyRNA *prop, Py_ssize_t start, Py_ssize_t stop, Py_ssize_t length);
static short pyrna_rotation_euler_order_get(PointerRNA *ptr, PropertyRNA **prop_eul_order, short order_fallback);
@@ -3847,9 +3847,11 @@ static PyObject *foreach_getset(BPy_PropertyRNA *self, PyObject *args, int set)
case PROP_RAW_DOUBLE:
item= PyFloat_FromDouble((double) ((double *)array)[i]);
break;
case PROP_RAW_UNSET:
default: /* PROP_RAW_UNSET */
/* should never happen */
BLI_assert(!"Invalid array type - get");
item= Py_None;
Py_INCREF(item);
break;
}
@@ -4546,7 +4548,7 @@ PyTypeObject pyrna_struct_meta_idprop_Type= {
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */ /* DEPRECATED in python 3.0! */
NULL, /* tp_compare */ /* deprecated in python 3.0! */
NULL, /* tp_repr */
/* Method suites for standard classes */

52
source/blender/python/mathutils/CMakeLists.txt Normal file
View File

@@ -0,0 +1,52 @@
# ***** BEGIN GPL LICENSE BLOCK *****
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# Contributor(s): Campbell Barton
#
# ***** END GPL LICENSE BLOCK *****
set(INC
.
../../blenlib
../../blenkernel
../../makesdna
../../../../intern/guardedalloc
)
set(INC_SYS
${PYTHON_INCLUDE_DIRS}
)
set(SRC
mathutils.c
mathutils_Color.c
mathutils_Euler.c
mathutils_Matrix.c
mathutils_Quaternion.c
mathutils_Vector.c
mathutils_geometry.c
mathutils.h
mathutils_Color.h
mathutils_Euler.h
mathutils_Matrix.h
mathutils_Quaternion.h
mathutils_Vector.h
mathutils_geometry.h
)
blender_add_lib(bf_python_mathutils "${SRC}" "${INC}" "${INC_SYS}")

69
source/blender/python/generic/mathutils.c → source/blender/python/mathutils/mathutils.c
View File

@@ -57,8 +57,16 @@ static int mathutils_array_parse_fast(float *array, int array_min, int array_max
size= PySequence_Fast_GET_SIZE(value_fast);
if(size > array_max || size < array_min) {
if (array_max == array_min) PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected %d", error_prefix, size, array_max);
else PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected [%d - %d]", error_prefix, size, array_min, array_max);
if (array_max == array_min) {
PyErr_Format(PyExc_ValueError,
"%.200s: sequence size is %d, expected %d",
error_prefix, size, array_max);
}
else {
PyErr_Format(PyExc_ValueError,
"%.200s: sequence size is %d, expected [%d - %d]",
error_prefix, size, array_min, array_max);
}
Py_DECREF(value_fast);
return -1;
}
@@ -67,7 +75,10 @@ static int mathutils_array_parse_fast(float *array, int array_min, int array_max
do {
i--;
if(((array[i]= PyFloat_AsDouble((item= PySequence_Fast_GET_ITEM(value_fast, i)))) == -1.0f) && PyErr_Occurred()) {
PyErr_Format(PyExc_ValueError, "%.200s: sequence index %d expected a number, found '%.200s' type, ", error_prefix, i, Py_TYPE(item)->tp_name);
PyErr_Format(PyExc_TypeError,
"%.200s: sequence index %d expected a number, "
"found '%.200s' type, ",
error_prefix, i, Py_TYPE(item)->tp_name);
Py_DECREF(value_fast);
return -1;
}
@@ -93,8 +104,16 @@ int mathutils_array_parse(float *array, int array_min, int array_max, PyObject *
}
if(size > array_max || size < array_min) {
if (array_max == array_min) PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected %d", error_prefix, size, array_max);
else PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected [%d - %d]", error_prefix, size, array_min, array_max);
if (array_max == array_min) {
PyErr_Format(PyExc_ValueError,
"%.200s: sequence size is %d, expected %d",
error_prefix, size, array_max);
}
else {
PyErr_Format(PyExc_ValueError,
"%.200s: sequence size is %d, expected [%d - %d]",
error_prefix, size, array_min, array_max);
}
return -1;
}
@@ -135,7 +154,9 @@ int mathutils_any_to_rotmat(float rmat[3][3], PyObject *value, const char *error
return -1;
}
else if(((MatrixObject *)value)->col_size < 3 || ((MatrixObject *)value)->row_size < 3) {
PyErr_Format(PyExc_ValueError, "%.200s: matrix must have minimum 3x3 dimensions", error_prefix);
PyErr_Format(PyExc_ValueError,
"%.200s: matrix must have minimum 3x3 dimensions",
error_prefix);
return -1;
}
else {
@@ -145,7 +166,9 @@ int mathutils_any_to_rotmat(float rmat[3][3], PyObject *value, const char *error
}
}
else {
PyErr_Format(PyExc_TypeError, "%.200s: expected a Euler, Quaternion or Matrix type, found %.200s", error_prefix, Py_TYPE(value)->tp_name);
PyErr_Format(PyExc_TypeError,
"%.200s: expected a Euler, Quaternion or Matrix type, "
"found %.200s", error_prefix, Py_TYPE(value)->tp_name);
return -1;
}
}
@@ -213,8 +236,11 @@ int _BaseMathObject_ReadCallback(BaseMathObject *self)
if(cb->get(self, self->cb_subtype) != -1)
return 0;
if(!PyErr_Occurred())
PyErr_Format(PyExc_RuntimeError, "%s read, user has become invalid", Py_TYPE(self)->tp_name);
if(!PyErr_Occurred()) {
PyErr_Format(PyExc_RuntimeError,
"%s read, user has become invalid",
Py_TYPE(self)->tp_name);
}
return -1;
}
@@ -224,8 +250,11 @@ int _BaseMathObject_WriteCallback(BaseMathObject *self)
if(cb->set(self, self->cb_subtype) != -1)
return 0;
if(!PyErr_Occurred())
PyErr_Format(PyExc_RuntimeError, "%s write, user has become invalid", Py_TYPE(self)->tp_name);
if(!PyErr_Occurred()) {
PyErr_Format(PyExc_RuntimeError,
"%s write, user has become invalid",
Py_TYPE(self)->tp_name);
}
return -1;
}
@@ -235,8 +264,11 @@ int _BaseMathObject_ReadIndexCallback(BaseMathObject *self, int index)
if(cb->get_index(self, self->cb_subtype, index) != -1)
return 0;
if(!PyErr_Occurred())
PyErr_Format(PyExc_RuntimeError, "%s read index, user has become invalid", Py_TYPE(self)->tp_name);
if(!PyErr_Occurred()) {
PyErr_Format(PyExc_RuntimeError,
"%s read index, user has become invalid",
Py_TYPE(self)->tp_name);
}
return -1;
}
@@ -246,8 +278,11 @@ int _BaseMathObject_WriteIndexCallback(BaseMathObject *self, int index)
if(cb->set_index(self, self->cb_subtype, index) != -1)
return 0;
if(!PyErr_Occurred())
PyErr_Format(PyExc_RuntimeError, "%s write index, user has become invalid", Py_TYPE(self)->tp_name);
if(!PyErr_Occurred()) {
PyErr_Format(PyExc_RuntimeError,
"%s write index, user has become invalid",
Py_TYPE(self)->tp_name);
}
return -1;
}
@@ -310,7 +345,7 @@ static struct PyModuleDef M_Mathutils_module_def = {
NULL, /* m_free */
};
PyMODINIT_FUNC BPyInit_mathutils(void)
PyMODINIT_FUNC PyInit_mathutils(void)
{
PyObject *submodule;
PyObject *item;
@@ -336,7 +371,7 @@ PyMODINIT_FUNC BPyInit_mathutils(void)
PyModule_AddObject(submodule, "Color", (PyObject *)&color_Type);
/* submodule */
PyModule_AddObject(submodule, "geometry", (item=BPyInit_mathutils_geometry()));
PyModule_AddObject(submodule, "geometry", (item=PyInit_mathutils_geometry()));
/* XXX, python doesnt do imports with this usefully yet
* 'from mathutils.geometry import PolyFill'
* ...fails without this. */

2
source/blender/python/generic/mathutils.h → source/blender/python/mathutils/mathutils.h
View File

@@ -67,7 +67,7 @@ int BaseMathObject_traverse(BaseMathObject *self, visitproc visit, void *arg);
int BaseMathObject_clear(BaseMathObject *self);
void BaseMathObject_dealloc(BaseMathObject * self);
PyMODINIT_FUNC BPyInit_mathutils(void);
PyMODINIT_FUNC PyInit_mathutils(void);
int EXPP_FloatsAreEqual(float A, float B, int floatSteps);
int EXPP_VectorsAreEqual(float *vecA, float *vecB, int size, int floatSteps);

87
source/blender/python/generic/mathutils_Color.c → source/blender/python/mathutils/mathutils_Color.c
View File

@@ -43,7 +43,9 @@ static PyObject *Color_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
float col[3]= {0.0f, 0.0f, 0.0f};
if(kwds && PyDict_Size(kwds)) {
PyErr_SetString(PyExc_TypeError, "mathutils.Color(): takes no keyword args");
PyErr_SetString(PyExc_TypeError,
"mathutils.Color(): "
"takes no keyword args");
return NULL;
}
@@ -55,7 +57,9 @@ static PyObject *Color_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
return NULL;
break;
default:
PyErr_SetString(PyExc_TypeError, "mathutils.Color(): more then a single arg given");
PyErr_SetString(PyExc_TypeError,
"mathutils.Color(): "
"more then a single arg given");
return NULL;
}
return newColorObject(col, Py_NEW, type);
@@ -174,7 +178,9 @@ static PyObject *Color_item(ColorObject * self, int i)
if(i<0) i= COLOR_SIZE-i;
if(i < 0 || i >= COLOR_SIZE) {
PyErr_SetString(PyExc_IndexError, "color[attribute]: array index out of range");
PyErr_SetString(PyExc_IndexError,
"color[attribute]: "
"array index out of range");
return NULL;
}
@@ -191,14 +197,17 @@ static int Color_ass_item(ColorObject * self, int i, PyObject *value)
float f = PyFloat_AsDouble(value);
if(f == -1 && PyErr_Occurred()) { // parsed item not a number
PyErr_SetString(PyExc_TypeError, "color[attribute] = x: argument not a number");
PyErr_SetString(PyExc_TypeError,
"color[attribute] = x: "
"argument not a number");
return -1;
}
if(i<0) i= COLOR_SIZE-i;
if(i < 0 || i >= COLOR_SIZE){
PyErr_SetString(PyExc_IndexError, "color[attribute] = x: array assignment index out of range");
PyErr_SetString(PyExc_IndexError, "color[attribute] = x: "
"array assignment index out of range");
return -1;
}
@@ -250,7 +259,9 @@ static int Color_ass_slice(ColorObject *self, int begin, int end, PyObject *seq)
return -1;
if(size != (end - begin)){
PyErr_SetString(PyExc_TypeError, "color[begin:end] = []: size mismatch in slice assignment");
PyErr_SetString(PyExc_ValueError,
"color[begin:end] = []: "
"size mismatch in slice assignment");
return -1;
}
@@ -285,12 +296,15 @@ static PyObject *Color_subscript(ColorObject *self, PyObject *item)
return Color_slice(self, start, stop);
}
else {
PyErr_SetString(PyExc_TypeError, "slice steps not supported with color");
PyErr_SetString(PyExc_IndexError,
"slice steps not supported with color");
return NULL;
}
}
else {
PyErr_Format(PyExc_TypeError, "color indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
PyErr_Format(PyExc_TypeError,
"color indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return NULL;
}
}
@@ -314,12 +328,15 @@ static int Color_ass_subscript(ColorObject *self, PyObject *item, PyObject *valu
if (step == 1)
return Color_ass_slice(self, start, stop, value);
else {
PyErr_SetString(PyExc_TypeError, "slice steps not supported with color");
PyErr_SetString(PyExc_IndexError,
"slice steps not supported with color");
return -1;
}
}
else {
PyErr_Format(PyExc_TypeError, "color indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
PyErr_Format(PyExc_TypeError,
"color indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return -1;
}
}
@@ -354,7 +371,9 @@ static PyObject *Color_add(PyObject *v1, PyObject *v2)
float col[COLOR_SIZE];
if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) {
PyErr_SetString(PyExc_AttributeError, "Color addition: arguments not valid for this operation");
PyErr_SetString(PyExc_TypeError,
"Color addition: "
"arguments not valid for this operation");
return NULL;
}
color1 = (ColorObject*)v1;
@@ -374,7 +393,9 @@ static PyObject *Color_iadd(PyObject *v1, PyObject *v2)
ColorObject *color1 = NULL, *color2 = NULL;
if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) {
PyErr_SetString(PyExc_AttributeError, "Color addition: arguments not valid for this operation");
PyErr_SetString(PyExc_TypeError,
"Color addition: "
"arguments not valid for this operation");
return NULL;
}
color1 = (ColorObject*)v1;
@@ -397,7 +418,9 @@ static PyObject *Color_sub(PyObject *v1, PyObject *v2)
float col[COLOR_SIZE];
if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) {
PyErr_SetString(PyExc_AttributeError, "Color subtraction: arguments not valid for this operation");
PyErr_SetString(PyExc_TypeError,
"Color subtraction: "
"arguments not valid for this operation");
return NULL;
}
color1 = (ColorObject*)v1;
@@ -417,7 +440,9 @@ static PyObject *Color_isub(PyObject *v1, PyObject *v2)
ColorObject *color1= NULL, *color2= NULL;
if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) {
PyErr_SetString(PyExc_AttributeError, "Color subtraction: arguments not valid for this operation");
PyErr_SetString(PyExc_TypeError,
"Color subtraction: "
"arguments not valid for this operation");
return NULL;
}
color1 = (ColorObject*)v1;
@@ -476,7 +501,10 @@ static PyObject *Color_mul(PyObject *v1, PyObject *v2)
BLI_assert(!"internal error");
}
PyErr_Format(PyExc_TypeError, "Color multiplication: not supported between '%.200s' and '%.200s' types", Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
PyErr_Format(PyExc_TypeError,
"Color multiplication: not supported between "
"'%.200s' and '%.200s' types",
Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
return NULL;
}
@@ -491,20 +519,25 @@ static PyObject *Color_div(PyObject *v1, PyObject *v2)
return NULL;
}
else {
PyErr_SetString(PyExc_TypeError, "Color division not supported in this order");
PyErr_SetString(PyExc_TypeError,
"Color division not supported in this order");
return NULL;
}
/* make sure v1 is always the vector */
if (((scalar= PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred())==0) { /* COLOR * FLOAT */
if(scalar==0.0f) {
PyErr_SetString(PyExc_ZeroDivisionError, "Color division: divide by zero error");
PyErr_SetString(PyExc_ZeroDivisionError,
"Color division: divide by zero error");
return NULL;
}
return color_mul_float(color1, 1.0f / scalar);
}
PyErr_Format(PyExc_TypeError, "Color multiplication: not supported between '%.200s' and '%.200s' types", Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
PyErr_Format(PyExc_TypeError,
"Color multiplication: not supported between "
"'%.200s' and '%.200s' types",
Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
return NULL;
}
@@ -522,7 +555,9 @@ static PyObject *Color_imul(PyObject *v1, PyObject *v2)
mul_vn_fl(color->col, COLOR_SIZE, scalar);
}
else {
PyErr_SetString(PyExc_TypeError, "Color multiplication: arguments not acceptable for this operation");
PyErr_SetString(PyExc_TypeError,
"Color multiplication: "
"arguments not acceptable for this operation");
return NULL;
}
@@ -543,14 +578,17 @@ static PyObject *Color_idiv(PyObject *v1, PyObject *v2)
/* only support color /= float */
if (((scalar= PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred())==0) { /* COLOR /= FLOAT */
if(scalar==0.0f) {
PyErr_SetString(PyExc_ZeroDivisionError, "Color division: divide by zero error");
PyErr_SetString(PyExc_ZeroDivisionError,
"Color division: divide by zero error");
return NULL;
}
mul_vn_fl(color->col, COLOR_SIZE, 1.0f / scalar);
}
else {
PyErr_SetString(PyExc_TypeError, "Color multiplication: arguments not acceptable for this operation");
PyErr_SetString(PyExc_TypeError,
"Color multiplication: "
"arguments not acceptable for this operation");
return NULL;
}
@@ -642,7 +680,9 @@ static int Color_setChannelHSV(ColorObject * self, PyObject *value, void * type)
float f = PyFloat_AsDouble(value);
if(f == -1 && PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, "color.h/s/v = value: argument not a number");
PyErr_SetString(PyExc_TypeError,
"color.h/s/v = value: "
"argument not a number");
return -1;
}
@@ -808,8 +848,7 @@ PyObject *newColorObject(float *col, int type, PyTypeObject *base_type)
self->wrapped = Py_NEW;
}
else {
PyErr_SetString(PyExc_RuntimeError, "Color(): invalid type");
return NULL;
Py_FatalError("Color(): invalid type!");
}
}

0
source/blender/python/generic/mathutils_Color.h → source/blender/python/mathutils/mathutils_Color.h
View File

54
source/blender/python/generic/mathutils_Euler.c → source/blender/python/mathutils/mathutils_Euler.c
View File

@@ -38,10 +38,6 @@
#include "BLI_math.h"
#include "BLI_utildefines.h"
#ifndef int32_t
#include "BLO_sys_types.h"
#endif
#define EULER_SIZE 3
//----------------------------------mathutils.Euler() -------------------
@@ -55,7 +51,9 @@ static PyObject *Euler_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
short order= EULER_ORDER_XYZ;
if(kwds && PyDict_Size(kwds)) {
PyErr_SetString(PyExc_TypeError, "mathutils.Euler(): takes no keyword args");
PyErr_SetString(PyExc_TypeError,
"mathutils.Euler(): "
"takes no keyword args");
return NULL;
}
@@ -87,7 +85,7 @@ static const char *euler_order_str(EulerObject *self)
short euler_order_from_string(const char *str, const char *error_prefix)
{
if((str[0] && str[1] && str[2] && str[3]=='\0')) {
switch(*((int32_t *)str)) {
switch(*((PY_INT32_T *)str)) {
case 'X'|'Y'<<8|'Z'<<16: return EULER_ORDER_XYZ;
case 'X'|'Z'<<8|'Y'<<16: return EULER_ORDER_XZY;
case 'Y'|'X'<<8|'Z'<<16: return EULER_ORDER_YXZ;
@@ -97,7 +95,9 @@ short euler_order_from_string(const char *str, const char *error_prefix)
}
}
PyErr_Format(PyExc_TypeError, "%s: invalid euler order '%s'", error_prefix, str);
PyErr_Format(PyExc_ValueError,
"%s: invalid euler order '%s'",
error_prefix, str);
return -1;
}
@@ -199,11 +199,14 @@ 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')){
PyErr_SetString(PyExc_TypeError, "euler.rotate(): expected axis to be 'X', 'Y' or 'Z'");
PyErr_SetString(PyExc_ValueError, "euler.rotate(): "
"expected axis to be 'X', 'Y' or 'Z'");
return NULL;
}
@@ -360,7 +363,9 @@ static PyObject *Euler_item(EulerObject * self, int i)
if(i<0) i= EULER_SIZE-i;
if(i < 0 || i >= EULER_SIZE) {
PyErr_SetString(PyExc_IndexError, "euler[attribute]: array index out of range");
PyErr_SetString(PyExc_IndexError,
"euler[attribute]: "
"array index out of range");
return NULL;
}
@@ -377,14 +382,18 @@ static int Euler_ass_item(EulerObject * self, int i, PyObject *value)
float f = PyFloat_AsDouble(value);
if(f == -1 && PyErr_Occurred()) { // parsed item not a number
PyErr_SetString(PyExc_TypeError, "euler[attribute] = x: argument not a number");
PyErr_SetString(PyExc_TypeError,
"euler[attribute] = x: "
"argument not a number");
return -1;
}
if(i<0) i= EULER_SIZE-i;
if(i < 0 || i >= EULER_SIZE){
PyErr_SetString(PyExc_IndexError, "euler[attribute] = x: array assignment index out of range");
PyErr_SetString(PyExc_IndexError,
"euler[attribute] = x: "
"array assignment index out of range");
return -1;
}
@@ -436,7 +445,9 @@ static int Euler_ass_slice(EulerObject *self, int begin, int end, PyObject *seq)
return -1;
if(size != (end - begin)){
PyErr_SetString(PyExc_TypeError, "euler[begin:end] = []: size mismatch in slice assignment");
PyErr_SetString(PyExc_ValueError,
"euler[begin:end] = []: "
"size mismatch in slice assignment");
return -1;
}
@@ -471,12 +482,15 @@ static PyObject *Euler_subscript(EulerObject *self, PyObject *item)
return Euler_slice(self, start, stop);
}
else {
PyErr_SetString(PyExc_TypeError, "slice steps not supported with eulers");
PyErr_SetString(PyExc_IndexError,
"slice steps not supported with eulers");
return NULL;
}
}
else {
PyErr_Format(PyExc_TypeError, "euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
PyErr_Format(PyExc_TypeError,
"euler indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return NULL;
}
}
@@ -501,12 +515,15 @@ static int Euler_ass_subscript(EulerObject *self, PyObject *item, PyObject *valu
if (step == 1)
return Euler_ass_slice(self, start, stop, value);
else {
PyErr_SetString(PyExc_TypeError, "slice steps not supported with euler");
PyErr_SetString(PyExc_IndexError,
"slice steps not supported with euler");
return -1;
}
}
else {
PyErr_Format(PyExc_TypeError, "euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
PyErr_Format(PyExc_TypeError,
"euler indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return -1;
}
}
@@ -680,8 +697,7 @@ PyObject *newEulerObject(float *eul, short order, int type, PyTypeObject *base_t
self->wrapped = Py_NEW;
}
else {
PyErr_SetString(PyExc_RuntimeError, "Euler(): invalid type");
return NULL;
Py_FatalError("Euler(): invalid type!");
}
self->order= order;

0
source/blender/python/generic/mathutils_Euler.h → source/blender/python/mathutils/mathutils_Euler.h
View File

269
source/blender/python/generic/mathutils_Matrix.c → source/blender/python/mathutils/mathutils_Matrix.c
View File

@@ -35,7 +35,6 @@
#include "mathutils.h"
#include "BLI_math.h"
#include "BLI_blenlib.h"
#include "BLI_utildefines.h"
static PyObject *Matrix_copy(MatrixObject *self);
@@ -119,7 +118,9 @@ Mathutils_Callback mathutils_matrix_vector_cb = {
static PyObject *Matrix_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
if(kwds && PyDict_Size(kwds)) {
PyErr_SetString(PyExc_TypeError, "mathutils.Matrix(): takes no keyword args");
PyErr_SetString(PyExc_TypeError,
"mathutils.Matrix(): "
"takes no keyword args");
return NULL;
}
@@ -130,7 +131,8 @@ static PyObject *Matrix_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
PyObject *arg= PyTuple_GET_ITEM(args, 0);
const unsigned short row_size= PySequence_Size(arg); /* -1 is an error, size checks will accunt for this */
/* -1 is an error, size checks will accunt for this */
const unsigned short row_size= PySequence_Size(arg);
if(row_size >= 2 && row_size <= 4) {
PyObject *item= PySequence_GetItem(arg, 0);
@@ -152,7 +154,9 @@ static PyObject *Matrix_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
}
/* will overwrite error */
PyErr_SetString(PyExc_TypeError, "mathutils.Matrix(): expects no args or 2-4 numeric sequences");
PyErr_SetString(PyExc_TypeError,
"mathutils.Matrix(): "
"expects no args or 2-4 numeric sequences");
return NULL;
}
@@ -211,14 +215,19 @@ static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args)
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
if(!PyArg_ParseTuple(args, "di|O", &angle, &matSize, &vec)) {
PyErr_SetString(PyExc_TypeError, "mathutils.RotationMatrix(angle, size, axis): expected float int and a string or vector");
PyErr_SetString(PyExc_TypeError,
"mathutils.RotationMatrix(angle, size, axis): "
"expected float int and a string or vector");
return NULL;
}
if(vec && PyUnicode_Check(vec)) {
axis= _PyUnicode_AsString((PyObject *)vec);
if(axis==NULL || axis[0]=='\0' || axis[1]!='\0' || axis[0] < 'X' || axis[0] > 'Z') {
PyErr_SetString(PyExc_TypeError, "mathutils.RotationMatrix(): 3rd argument axis value must be a 3D vector or a string in 'X', 'Y', 'Z'");
PyErr_SetString(PyExc_ValueError,
"mathutils.RotationMatrix(): "
"3rd argument axis value must be a 3D vector "
"or a string in 'X', 'Y', 'Z'");
return NULL;
}
else {
@@ -230,15 +239,21 @@ static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args)
angle= angle_wrap_rad(angle);
if(matSize != 2 && matSize != 3 && matSize != 4) {
PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): can only return a 2x2 3x3 or 4x4 matrix");
PyErr_SetString(PyExc_ValueError,
"mathutils.RotationMatrix(): "
"can only return a 2x2 3x3 or 4x4 matrix");
return NULL;
}
if(matSize == 2 && (vec != NULL)) {
PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): cannot create a 2x2 rotation matrix around arbitrary axis");
PyErr_SetString(PyExc_ValueError,
"mathutils.RotationMatrix(): "
"cannot create a 2x2 rotation matrix around arbitrary axis");
return NULL;
}
if((matSize == 3 || matSize == 4) && (axis == NULL) && (vec == NULL)) {
PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): axis of rotation for 3d and 4d matrices is required");
PyErr_SetString(PyExc_ValueError,
"mathutils.RotationMatrix(): "
"axis of rotation for 3d and 4d matrices is required");
return NULL;
}
@@ -284,7 +299,8 @@ static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args)
}
else {
/* should never get here */
PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): unknown error");
PyErr_SetString(PyExc_ValueError,
"mathutils.RotationMatrix(): unknown error");
return NULL;
}
@@ -348,7 +364,9 @@ static PyObject *C_Matrix_Scale(PyObject *cls, PyObject *args)
return NULL;
}
if(matSize != 2 && matSize != 3 && matSize != 4) {
PyErr_SetString(PyExc_AttributeError, "Matrix.Scale(): can only return a 2x2 3x3 or 4x4 matrix");
PyErr_SetString(PyExc_ValueError,
"Matrix.Scale(): "
"can only return a 2x2 3x3 or 4x4 matrix");
return NULL;
}
if(vec) {
@@ -361,7 +379,8 @@ static PyObject *C_Matrix_Scale(PyObject *cls, PyObject *args)
if(matSize == 2) {
mat[0] = factor;
mat[3] = factor;
} else {
}
else {
mat[0] = factor;
mat[4] = factor;
mat[8] = factor;
@@ -383,7 +402,8 @@ static PyObject *C_Matrix_Scale(PyObject *cls, PyObject *args)
mat[1] = ((factor - 1) *(tvec[0] * tvec[1]));
mat[2] = ((factor - 1) *(tvec[0] * tvec[1]));
mat[3] = 1 + ((factor - 1) *(tvec[1] * tvec[1]));
} else {
}
else {
mat[0] = 1 + ((factor - 1) *(tvec[0] * tvec[0]));
mat[1] = ((factor - 1) *(tvec[0] * tvec[1]));
mat[2] = ((factor - 1) *(tvec[0] * tvec[2]));
@@ -430,7 +450,9 @@ static PyObject *C_Matrix_OrthoProjection(PyObject *cls, PyObject *args)
return NULL;
}
if(matSize != 2 && matSize != 3 && matSize != 4) {
PyErr_SetString(PyExc_AttributeError,"mathutils.Matrix.OrthoProjection(): can only return a 2x2 3x3 or 4x4 matrix");
PyErr_SetString(PyExc_ValueError,
"mathutils.Matrix.OrthoProjection(): "
"can only return a 2x2 3x3 or 4x4 matrix");
return NULL;
}
@@ -445,7 +467,10 @@ static PyObject *C_Matrix_OrthoProjection(PyObject *cls, PyObject *args)
mat[3]= 1.0f;
}
else {
PyErr_Format(PyExc_ValueError, "mathutils.Matrix.OrthoProjection(): unknown plane, expected: X, Y, not '%.200s'", plane);
PyErr_Format(PyExc_ValueError,
"mathutils.Matrix.OrthoProjection(): "
"unknown plane, expected: X, Y, not '%.200s'",
plane);
return NULL;
}
}
@@ -463,7 +488,10 @@ static PyObject *C_Matrix_OrthoProjection(PyObject *cls, PyObject *args)
mat[8]= 1.0f;
}
else {
PyErr_Format(PyExc_ValueError, "mathutils.Matrix.OrthoProjection(): unknown plane, expected: XY, XZ, YZ, not '%.200s'", plane);
PyErr_Format(PyExc_ValueError,
"mathutils.Matrix.OrthoProjection(): "
"unknown plane, expected: XY, XZ, YZ, not '%.200s'",
plane);
return NULL;
}
}
@@ -539,7 +567,9 @@ static PyObject *C_Matrix_Shear(PyObject *cls, PyObject *args)
return NULL;
}
if(matSize != 2 && matSize != 3 && matSize != 4) {
PyErr_SetString(PyExc_AttributeError,"mathutils.Matrix.Shear(): can only return a 2x2 3x3 or 4x4 matrix");
PyErr_SetString(PyExc_ValueError,
"mathutils.Matrix.Shear(): "
"can only return a 2x2 3x3 or 4x4 matrix");
return NULL;
}
@@ -547,7 +577,9 @@ static PyObject *C_Matrix_Shear(PyObject *cls, PyObject *args)
float const factor= PyFloat_AsDouble(fac);
if(factor==-1.0f && PyErr_Occurred()) {
PyErr_SetString(PyExc_AttributeError, "mathutils.Matrix.Shear(): the factor to be a float");
PyErr_SetString(PyExc_TypeError,
"mathutils.Matrix.Shear(): "
"the factor to be a float");
return NULL;
}
@@ -562,7 +594,9 @@ static PyObject *C_Matrix_Shear(PyObject *cls, PyObject *args)
mat[1] = factor;
}
else {
PyErr_SetString(PyExc_AttributeError, "Matrix.Shear(): expected: X, Y or wrong matrix size for shearing plane");
PyErr_SetString(PyExc_ValueError,
"Matrix.Shear(): "
"expected: X, Y or wrong matrix size for shearing plane");
return NULL;
}
}
@@ -592,7 +626,9 @@ static PyObject *C_Matrix_Shear(PyObject *cls, PyObject *args)
mat[2] = factor[1];
}
else {
PyErr_SetString(PyExc_AttributeError, "mathutils.Matrix.Shear(): expected: X, Y, XY, XZ, YZ");
PyErr_SetString(PyExc_ValueError,
"mathutils.Matrix.Shear(): "
"expected: X, Y, XY, XZ, YZ");
return NULL;
}
}
@@ -624,7 +660,8 @@ static float matrix_determinant_internal(MatrixObject *self)
self->matrix[1][1], self->matrix[1][2],
self->matrix[2][0], self->matrix[2][1],
self->matrix[2][2]);
} else {
}
else {
return determinant_m4((float (*)[4])self->contigPtr);
}
}
@@ -648,7 +685,9 @@ static PyObject *Matrix_to_quaternion(MatrixObject *self)
/*must be 3-4 cols, 3-4 rows, square matrix*/
if((self->col_size < 3) || (self->row_size < 3) || (self->col_size != self->row_size)) {
PyErr_SetString(PyExc_AttributeError, "Matrix.to_quat(): inappropriate matrix size - expects 3x3 or 4x4 matrix");
PyErr_SetString(PyExc_ValueError,
"matrix.to_quat(): "
"inappropriate matrix size - expects 3x3 or 4x4 matrix");
return NULL;
}
if(self->col_size == 3){
@@ -661,7 +700,7 @@ static PyObject *Matrix_to_quaternion(MatrixObject *self)
return newQuaternionObject(quat, Py_NEW, NULL);
}
/*---------------------------Matrix.toEuler() --------------------*/
/*---------------------------matrix.toEuler() --------------------*/
PyDoc_STRVAR(Matrix_to_euler_doc,
".. method:: to_euler(order, euler_compat)\n"
"\n"
@@ -710,12 +749,14 @@ static PyObject *Matrix_to_euler(MatrixObject *self, PyObject *args)
mat= tmat;
}
else {
PyErr_SetString(PyExc_AttributeError, "Matrix.to_euler(): inappropriate matrix size - expects 3x3 or 4x4 matrix");
PyErr_SetString(PyExc_ValueError,
"matrix.to_euler(): "
"inappropriate matrix size - expects 3x3 or 4x4 matrix");
return NULL;
}
if(order_str) {
order= euler_order_from_string(order_str, "Matrix.to_euler()");
order= euler_order_from_string(order_str, "matrix.to_euler()");
if(order == -1)
return NULL;
@@ -743,17 +784,20 @@ static PyObject *Matrix_resize_4x4(MatrixObject *self)
int x, first_row_elem, curr_pos, new_pos, blank_columns, blank_rows, index;
if(self->wrapped==Py_WRAP){
PyErr_SetString(PyExc_TypeError, "cannot resize wrapped data - make a copy and resize that");
PyErr_SetString(PyExc_TypeError,
"cannot resize wrapped data - make a copy and resize that");
return NULL;
}
if(self->cb_user){
PyErr_SetString(PyExc_TypeError, "cannot resize owned data - make a copy and resize that");
PyErr_SetString(PyExc_TypeError,
"cannot resize owned data - make a copy and resize that");
return NULL;
}
self->contigPtr = PyMem_Realloc(self->contigPtr, (sizeof(float) * 16));
if(self->contigPtr == NULL) {
PyErr_SetString(PyExc_MemoryError, "matrix.resize_4x4(): problem allocating pointer space");
PyErr_SetString(PyExc_MemoryError,
"matrix.resize_4x4(): problem allocating pointer space");
return NULL;
}
/*set row pointers*/
@@ -779,7 +823,7 @@ static PyObject *Matrix_resize_4x4(MatrixObject *self)
for(blank_columns = (4 - self->col_size); blank_columns > 0; blank_columns--){
self->contigPtr[new_pos + blank_columns] = 0.0f;
}
for(curr_pos = curr_pos; curr_pos >= first_row_elem; curr_pos--){
for( ; curr_pos >= first_row_elem; curr_pos--){
self->contigPtr[new_pos] = self->contigPtr[curr_pos];
new_pos--;
}
@@ -813,7 +857,8 @@ static PyObject *Matrix_to_4x4(MatrixObject *self)
}
/* TODO, 2x2 matrix */
PyErr_SetString(PyExc_TypeError, "Matrix.to_4x4(): inappropriate matrix size");
PyErr_SetString(PyExc_TypeError,
"matrix.to_4x4(): inappropriate matrix size");
return NULL;
}
@@ -833,7 +878,8 @@ static PyObject *Matrix_to_3x3(MatrixObject *self)
return NULL;
if((self->col_size < 3) || (self->row_size < 3)) {
PyErr_SetString(PyExc_AttributeError, "Matrix.to_3x3(): inappropriate matrix size");
PyErr_SetString(PyExc_TypeError,
"matrix.to_3x3(): inappropriate matrix size");
return NULL;
}
@@ -856,7 +902,9 @@ static PyObject *Matrix_to_translation(MatrixObject *self)
return NULL;
if((self->col_size < 3) || self->row_size < 4){
PyErr_SetString(PyExc_AttributeError, "Matrix.to_translation(): inappropriate matrix size");
PyErr_SetString(PyExc_TypeError,
"matrix.to_translation(): "
"inappropriate matrix size");
return NULL;
}
@@ -884,7 +932,9 @@ static PyObject *Matrix_to_scale(MatrixObject *self)
/*must be 3-4 cols, 3-4 rows, square matrix*/
if((self->col_size < 3) || (self->row_size < 3)) {
PyErr_SetString(PyExc_AttributeError, "Matrix.to_scale(): inappropriate matrix size, 3x3 minimum size");
PyErr_SetString(PyExc_TypeError,
"matrix.to_scale(): "
"inappropriate matrix size, 3x3 minimum size");
return NULL;
}
@@ -896,7 +946,7 @@ static PyObject *Matrix_to_scale(MatrixObject *self)
return newVectorObject(size, 3, Py_NEW, NULL);
}
/*---------------------------Matrix.invert() ---------------------*/
/*---------------------------matrix.invert() ---------------------*/
PyDoc_STRVAR(Matrix_invert_doc,
".. method:: invert()\n"
"\n"
@@ -918,7 +968,9 @@ static PyObject *Matrix_invert(MatrixObject *self)
return NULL;
if(self->row_size != self->col_size){
PyErr_SetString(PyExc_AttributeError, "Matrix.invert(ed): only square matrices are supported");
PyErr_SetString(PyExc_TypeError,
"matrix.invert(ed): "
"only square matrices are supported");
return NULL;
}
@@ -950,8 +1002,10 @@ static PyObject *Matrix_invert(MatrixObject *self)
}
/*transpose
Matrix_transpose(self);*/
} else {
PyErr_SetString(PyExc_ValueError, "matrix does not have an inverse");
}
else {
PyErr_SetString(PyExc_ValueError,
"matrix does not have an inverse");
return NULL;
}
@@ -995,7 +1049,8 @@ static PyObject *Matrix_rotate(MatrixObject *self, PyObject *value)
return NULL;
if(self->col_size != 3 || self->row_size != 3) {
PyErr_SetString(PyExc_ValueError, "Matrix must have 3x3 dimensions");
PyErr_SetString(PyExc_TypeError,
"Matrix must have 3x3 dimensions");
return NULL;
}
@@ -1008,7 +1063,7 @@ static PyObject *Matrix_rotate(MatrixObject *self, PyObject *value)
Py_RETURN_NONE;
}
/*---------------------------Matrix.decompose() ---------------------*/
/*---------------------------matrix.decompose() ---------------------*/
PyDoc_STRVAR(Matrix_decompose_doc,
".. method:: decompose()\n"
"\n"
@@ -1026,7 +1081,9 @@ static PyObject *Matrix_decompose(MatrixObject *self)
float size[3];
if(self->col_size != 4 || self->row_size != 4) {
PyErr_SetString(PyExc_AttributeError, "Matrix.decompose(): inappropriate matrix size - expects 4x4 matrix");
PyErr_SetString(PyExc_TypeError,
"matrix.decompose(): "
"inappropriate matrix size - expects 4x4 matrix");
return NULL;
}
@@ -1067,7 +1124,9 @@ static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args)
return NULL;
if(self->row_size != mat2->row_size || self->col_size != mat2->col_size) {
PyErr_SetString(PyExc_AttributeError, "matrix.lerp(): expects both matrix objects of the same dimensions");
PyErr_SetString(PyExc_ValueError,
"matrix.lerp(): "
"expects both matrix objects of the same dimensions");
return NULL;
}
@@ -1082,14 +1141,16 @@ static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args)
blend_m3_m3m3((float (*)[3])mat, (float (*)[3])self->contigPtr, (float (*)[3])mat2->contigPtr, fac);
}
else {
PyErr_SetString(PyExc_AttributeError, "matrix.lerp(): only 3x3 and 4x4 matrices supported");
PyErr_SetString(PyExc_ValueError,
"matrix.lerp(): "
"only 3x3 and 4x4 matrices supported");
return NULL;
}
return (PyObject*)newMatrixObject(mat, self->row_size, self->col_size, Py_NEW, Py_TYPE(self));
}
/*---------------------------Matrix.determinant() ----------------*/
/*---------------------------matrix.determinant() ----------------*/
PyDoc_STRVAR(Matrix_determinant_doc,
".. method:: determinant()\n"
"\n"
@@ -1106,13 +1167,15 @@ static PyObject *Matrix_determinant(MatrixObject *self)
return NULL;
if(self->row_size != self->col_size){
PyErr_SetString(PyExc_AttributeError, "Matrix.determinant: only square matrices are supported");
PyErr_SetString(PyExc_TypeError,
"matrix.determinant: "
"only square matrices are supported");
return NULL;
}
return PyFloat_FromDouble((double)matrix_determinant_internal(self));
}
/*---------------------------Matrix.transpose() ------------------*/
/*---------------------------matrix.transpose() ------------------*/
PyDoc_STRVAR(Matrix_transpose_doc,
".. method:: transpose()\n"
"\n"
@@ -1128,7 +1191,9 @@ static PyObject *Matrix_transpose(MatrixObject *self)
return NULL;
if(self->row_size != self->col_size){
PyErr_SetString(PyExc_AttributeError, "Matrix.transpose(d): only square matrices are supported");
PyErr_SetString(PyExc_TypeError,
"matrix.transpose(d): "
"only square matrices are supported");
return NULL;
}
@@ -1138,7 +1203,8 @@ static PyObject *Matrix_transpose(MatrixObject *self)
self->matrix[0][1] = t;
} else if(self->row_size == 3) {
transpose_m3((float (*)[3])self->contigPtr);
} else {
}
else {
transpose_m4((float (*)[4])self->contigPtr);
}
@@ -1159,7 +1225,7 @@ static PyObject *Matrix_transposed(MatrixObject *self)
return matrix__apply_to_copy((PyNoArgsFunction)Matrix_transpose, self);
}
/*---------------------------Matrix.zero() -----------------------*/
/*---------------------------matrix.zero() -----------------------*/
PyDoc_STRVAR(Matrix_zero_doc,
".. method:: zero()\n"
"\n"
@@ -1177,7 +1243,7 @@ static PyObject *Matrix_zero(MatrixObject *self)
Py_RETURN_NONE;
}
/*---------------------------Matrix.identity(() ------------------*/
/*---------------------------matrix.identity(() ------------------*/
PyDoc_STRVAR(Matrix_identity_doc,
".. method:: identity()\n"
"\n"
@@ -1194,7 +1260,9 @@ static PyObject *Matrix_identity(MatrixObject *self)
return NULL;
if(self->row_size != self->col_size){
PyErr_SetString(PyExc_AttributeError, "Matrix.identity: only square matrices are supported");
PyErr_SetString(PyExc_TypeError,
"matrix.identity: "
"only square matrices are supported");
return NULL;
}
@@ -1205,7 +1273,8 @@ static PyObject *Matrix_identity(MatrixObject *self)
self->matrix[1][1] = 1.0f;
} else if(self->row_size == 3) {
unit_m3((float (*)[3])self->contigPtr);
} else {
}
else {
unit_m4((float (*)[4])self->contigPtr);
}
@@ -1262,7 +1331,8 @@ static PyObject *Matrix_repr(MatrixObject *self)
" %R)", rows[0], rows[1], rows[2], rows[3]);
}
PyErr_SetString(PyExc_RuntimeError, "invalid matrix size");
PyErr_SetString(PyExc_RuntimeError,
"internal error!");
return NULL;
}
@@ -1321,7 +1391,9 @@ static PyObject *Matrix_item(MatrixObject *self, int i)
return NULL;
if(i < 0 || i >= self->row_size) {
PyErr_SetString(PyExc_IndexError, "matrix[attribute]: array index out of range");
PyErr_SetString(PyExc_IndexError,
"matrix[attribute]: "
"array index out of range");
return NULL;
}
return newVectorObject_cb((PyObject *)self, self->col_size, mathutils_matrix_vector_cb_index, i);
@@ -1336,7 +1408,8 @@ static int Matrix_ass_item(MatrixObject *self, int i, PyObject *value)
return -1;
if(i >= self->row_size || i < 0){
PyErr_SetString(PyExc_TypeError, "matrix[attribute] = x: bad column");
PyErr_SetString(PyExc_IndexError,
"matrix[attribute] = x: bad column");
return -1;
}
@@ -1399,7 +1472,9 @@ static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *va
if(PySequence_Fast_GET_SIZE(value_fast) != size) {
Py_DECREF(value_fast);
PyErr_SetString(PyExc_TypeError, "matrix[begin:end] = []: size mismatch in slice assignment");
PyErr_SetString(PyExc_ValueError,
"matrix[begin:end] = []: "
"size mismatch in slice assignment");
return -1;
}
@@ -1433,7 +1508,9 @@ static PyObject *Matrix_add(PyObject *m1, PyObject *m2)
mat2 = (MatrixObject*)m2;
if(!MatrixObject_Check(m1) || !MatrixObject_Check(m2)) {
PyErr_SetString(PyExc_AttributeError, "Matrix addition: arguments not valid for this operation");
PyErr_SetString(PyExc_TypeError,
"Matrix addition: "
"arguments not valid for this operation");
return NULL;
}
@@ -1441,7 +1518,9 @@ static PyObject *Matrix_add(PyObject *m1, PyObject *m2)
return NULL;
if(mat1->row_size != mat2->row_size || mat1->col_size != mat2->col_size){
PyErr_SetString(PyExc_AttributeError, "Matrix addition: matrices must have the same dimensions for this operation");
PyErr_SetString(PyExc_TypeError,
"Matrix addition: "
"matrices must have the same dimensions for this operation");
return NULL;
}
@@ -1460,7 +1539,9 @@ static PyObject *Matrix_sub(PyObject *m1, PyObject *m2)
mat2 = (MatrixObject*)m2;
if(!MatrixObject_Check(m1) || !MatrixObject_Check(m2)) {
PyErr_SetString(PyExc_AttributeError, "Matrix addition: arguments not valid for this operation");
PyErr_SetString(PyExc_TypeError,
"Matrix addition: "
"arguments not valid for this operation");
return NULL;
}
@@ -1468,7 +1549,9 @@ static PyObject *Matrix_sub(PyObject *m1, PyObject *m2)
return NULL;
if(mat1->row_size != mat2->row_size || mat1->col_size != mat2->col_size){
PyErr_SetString(PyExc_AttributeError, "Matrix addition: matrices must have the same dimensions for this operation");
PyErr_SetString(PyExc_TypeError,
"Matrix addition: "
"matrices must have the same dimensions for this operation");
return NULL;
}
@@ -1502,39 +1585,38 @@ static PyObject *Matrix_mul(PyObject *m1, PyObject *m2)
return NULL;
}
if(mat1 && mat2) { /*MATRIX * MATRIX*/
if(mat1->row_size != mat2->col_size){
PyErr_SetString(PyExc_AttributeError,"Matrix multiplication: matrix A rowsize must equal matrix B colsize");
if(mat1 && mat2) {
/*MATRIX * MATRIX*/
if(mat2->row_size != mat1->col_size){
PyErr_SetString(PyExc_ValueError,
"Matrix multiplication: "
"matrix A rowsize must equal matrix B colsize");
return NULL;
}
else {
float mat[16]= {0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f};
double dot = 0.0f;
float mat[16]= {0.0f};
int x, y, z;
for(x = 0; x < mat2->row_size; x++) {
for(y = 0; y < mat1->col_size; y++) {
for(z = 0; z < mat1->row_size; z++) {
dot += (mat1->matrix[z][y] * mat2->matrix[x][z]);
mat[x * mat2->col_size + y] += (mat2->matrix[x][z] * mat1->matrix[z][y]);
}
mat[((x * mat1->col_size) + y)] = (float)dot;
dot = 0.0f;
}
}
return newMatrixObject(mat, mat2->row_size, mat1->col_size, Py_NEW, Py_TYPE(mat1));
return newMatrixObject(mat, mat1->row_size, mat2->col_size, Py_NEW, Py_TYPE(mat1));
}
}
else if(mat2) {
if (((scalar= PyFloat_AsDouble(m1)) == -1.0f && PyErr_Occurred())==0) { /*FLOAT/INT * MATRIX */
/*FLOAT/INT * MATRIX */
if (((scalar= PyFloat_AsDouble(m1)) == -1.0f && PyErr_Occurred())==0) {
return matrix_mul_float(mat2, scalar);
}
}
else if(mat1) {
if (((scalar= PyFloat_AsDouble(m2)) == -1.0f && PyErr_Occurred())==0) { /*FLOAT/INT * MATRIX */
/*FLOAT/INT * MATRIX */
if (((scalar= PyFloat_AsDouble(m2)) == -1.0f && PyErr_Occurred())==0) {
return matrix_mul_float(mat1, scalar);
}
}
@@ -1542,7 +1624,10 @@ static PyObject *Matrix_mul(PyObject *m1, PyObject *m2)
BLI_assert(!"internal error");
}
PyErr_Format(PyExc_TypeError, "Matrix multiplication: not supported between '%.200s' and '%.200s' types", Py_TYPE(m1)->tp_name, Py_TYPE(m2)->tp_name);
PyErr_Format(PyExc_TypeError,
"Matrix multiplication: "
"not supported between '%.200s' and '%.200s' types",
Py_TYPE(m1)->tp_name, Py_TYPE(m2)->tp_name);
return NULL;
}
static PyObject* Matrix_inv(MatrixObject *self)
@@ -1591,12 +1676,15 @@ static PyObject *Matrix_subscript(MatrixObject* self, PyObject* item)
return Matrix_slice(self, start, stop);
}
else {
PyErr_SetString(PyExc_TypeError, "slice steps not supported with matricies");
PyErr_SetString(PyExc_IndexError,
"slice steps not supported with matricies");
return NULL;
}
}
else {
PyErr_Format(PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
PyErr_Format(PyExc_TypeError,
"matrix indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return NULL;
}
}
@@ -1620,12 +1708,15 @@ static int Matrix_ass_subscript(MatrixObject* self, PyObject* item, PyObject* va
if (step == 1)
return Matrix_ass_slice(self, start, stop, value);
else {
PyErr_SetString(PyExc_TypeError, "slice steps not supported with matricies");
PyErr_SetString(PyExc_IndexError,
"slice steps not supported with matricies");
return -1;
}
}
else {
PyErr_Format(PyExc_TypeError, "matrix indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
PyErr_Format(PyExc_TypeError,
"matrix indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return -1;
}
}
@@ -1693,7 +1784,9 @@ static PyObject *Matrix_median_scale_get(MatrixObject *self, void *UNUSED(closur
/*must be 3-4 cols, 3-4 rows, square matrix*/
if((self->col_size < 3) || (self->row_size < 3)) {
PyErr_SetString(PyExc_AttributeError, "Matrix.median_scale: inappropriate matrix size, 3x3 minimum");
PyErr_SetString(PyExc_AttributeError,
"matrix.median_scale: "
"inappropriate matrix size, 3x3 minimum");
return NULL;
}
@@ -1713,7 +1806,9 @@ static PyObject *Matrix_is_negative_get(MatrixObject *self, void *UNUSED(closure
else if(self->col_size == 3 && self->row_size == 3)
return PyBool_FromLong(is_negative_m3((float (*)[3])self->contigPtr));
else {
PyErr_SetString(PyExc_AttributeError, "Matrix.is_negative: inappropriate matrix size - expects 3x3 or 4x4 matrix");
PyErr_SetString(PyExc_AttributeError,
"matrix.is_negative: "
"inappropriate matrix size - expects 3x3 or 4x4 matrix");
return NULL;
}
}
@@ -1729,7 +1824,9 @@ static PyObject *Matrix_is_orthogonal_get(MatrixObject *self, void *UNUSED(closu
else if(self->col_size == 3 && self->row_size == 3)
return PyBool_FromLong(is_orthogonal_m3((float (*)[3])self->contigPtr));
else {
PyErr_SetString(PyExc_AttributeError, "Matrix.is_orthogonal: inappropriate matrix size - expects 3x3 or 4x4 matrix");
PyErr_SetString(PyExc_AttributeError,
"matrix.is_orthogonal: "
"inappropriate matrix size - expects 3x3 or 4x4 matrix");
return NULL;
}
}
@@ -1865,7 +1962,9 @@ PyObject *newMatrixObject(float *mat, const unsigned short rowSize, const unsign
/*matrix objects can be any 2-4row x 2-4col matrix*/
if(rowSize < 2 || rowSize > 4 || colSize < 2 || colSize > 4) {
PyErr_SetString(PyExc_RuntimeError, "matrix(): row and column sizes must be between 2 and 4");
PyErr_SetString(PyExc_RuntimeError,
"Matrix(): "
"row and column sizes must be between 2 and 4");
return NULL;
}
@@ -1891,7 +1990,9 @@ PyObject *newMatrixObject(float *mat, const unsigned short rowSize, const unsign
else if (type == Py_NEW){
self->contigPtr = PyMem_Malloc(rowSize * colSize * sizeof(float));
if(self->contigPtr == NULL) { /*allocation failure*/
PyErr_SetString(PyExc_MemoryError, "matrix(): problem allocating pointer space");
PyErr_SetString(PyExc_MemoryError,
"Matrix(): "
"problem allocating pointer space");
return NULL;
}
/*pointer array points to contigous memory*/
@@ -1913,7 +2014,7 @@ PyObject *newMatrixObject(float *mat, const unsigned short rowSize, const unsign
self->wrapped = Py_NEW;
}
else {
PyErr_SetString(PyExc_RuntimeError, "Matrix(): invalid type");
Py_FatalError("Matrix(): invalid type!");
return NULL;
}
}

0
source/blender/python/generic/mathutils_Matrix.h → source/blender/python/mathutils/mathutils_Matrix.h
View File

61
source/blender/python/generic/mathutils_Quaternion.c → source/blender/python/mathutils/mathutils_Quaternion.c
View File

@@ -235,7 +235,9 @@ static PyObject *Quaternion_slerp(QuaternionObject *self, PyObject *args)
float tquat[QUAT_SIZE], quat[QUAT_SIZE], fac;
if(!PyArg_ParseTuple(args, "Of:slerp", &value, &fac)) {
PyErr_SetString(PyExc_TypeError, "quat.slerp(): expected Quaternion types and float");
PyErr_SetString(PyExc_TypeError,
"quat.slerp(): "
"expected Quaternion types and float");
return NULL;
}
@@ -246,7 +248,9 @@ static PyObject *Quaternion_slerp(QuaternionObject *self, PyObject *args)
return NULL;
if(fac > 1.0f || fac < 0.0f) {
PyErr_SetString(PyExc_AttributeError, "quat.slerp(): interpolation factor must be between 0.0 and 1.0");
PyErr_SetString(PyExc_ValueError,
"quat.slerp(): "
"interpolation factor must be between 0.0 and 1.0");
return NULL;
}
@@ -498,7 +502,9 @@ static PyObject *Quaternion_item(QuaternionObject *self, int i)
if(i<0) i= QUAT_SIZE-i;
if(i < 0 || i >= QUAT_SIZE) {
PyErr_SetString(PyExc_IndexError, "quaternion[attribute]: array index out of range");
PyErr_SetString(PyExc_IndexError,
"quaternion[attribute]: "
"array index out of range");
return NULL;
}
@@ -514,14 +520,18 @@ static int Quaternion_ass_item(QuaternionObject *self, int i, PyObject *ob)
{
float scalar= (float)PyFloat_AsDouble(ob);
if(scalar==-1.0f && PyErr_Occurred()) { /* parsed item not a number */
PyErr_SetString(PyExc_TypeError, "quaternion[index] = x: index argument not a number");
PyErr_SetString(PyExc_TypeError,
"quaternion[index] = x: "
"index argument not a number");
return -1;
}
if(i<0) i= QUAT_SIZE-i;
if(i < 0 || i >= QUAT_SIZE){
PyErr_SetString(PyExc_IndexError, "quaternion[attribute] = x: array assignment index out of range");
PyErr_SetString(PyExc_IndexError,
"quaternion[attribute] = x: "
"array assignment index out of range");
return -1;
}
self->quat[i] = scalar;
@@ -572,7 +582,9 @@ static int Quaternion_ass_slice(QuaternionObject *self, int begin, int end, PyOb
return -1;
if(size != (end - begin)){
PyErr_SetString(PyExc_TypeError, "quaternion[begin:end] = []: size mismatch in slice assignment");
PyErr_SetString(PyExc_ValueError,
"quaternion[begin:end] = []: "
"size mismatch in slice assignment");
return -1;
}
@@ -608,12 +620,15 @@ static PyObject *Quaternion_subscript(QuaternionObject *self, PyObject *item)
return Quaternion_slice(self, start, stop);
}
else {
PyErr_SetString(PyExc_TypeError, "slice steps not supported with quaternions");
PyErr_SetString(PyExc_IndexError,
"slice steps not supported with quaternions");
return NULL;
}
}
else {
PyErr_Format(PyExc_TypeError, "quaternion indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
PyErr_Format(PyExc_TypeError,
"quaternion indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return NULL;
}
}
@@ -638,12 +653,15 @@ static int Quaternion_ass_subscript(QuaternionObject *self, PyObject *item, PyOb
if (step == 1)
return Quaternion_ass_slice(self, start, stop, value);
else {
PyErr_SetString(PyExc_TypeError, "slice steps not supported with quaternion");
PyErr_SetString(PyExc_IndexError,
"slice steps not supported with quaternion");
return -1;
}
}
else {
PyErr_Format(PyExc_TypeError, "quaternion indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
PyErr_Format(PyExc_TypeError,
"quaternion indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return -1;
}
}
@@ -657,7 +675,9 @@ static PyObject *Quaternion_add(PyObject *q1, PyObject *q2)
QuaternionObject *quat1 = NULL, *quat2 = NULL;
if(!QuaternionObject_Check(q1) || !QuaternionObject_Check(q2)) {
PyErr_SetString(PyExc_AttributeError, "Quaternion addition: arguments not valid for this operation");
PyErr_SetString(PyExc_TypeError,
"Quaternion addition: "
"arguments not valid for this operation");
return NULL;
}
quat1 = (QuaternionObject*)q1;
@@ -678,7 +698,9 @@ static PyObject *Quaternion_sub(PyObject *q1, PyObject *q2)
QuaternionObject *quat1 = NULL, *quat2 = NULL;
if(!QuaternionObject_Check(q1) || !QuaternionObject_Check(q2)) {
PyErr_SetString(PyExc_AttributeError, "Quaternion addition: arguments not valid for this operation");
PyErr_SetString(PyExc_TypeError,
"Quaternion addition: "
"arguments not valid for this operation");
return NULL;
}
@@ -740,7 +762,10 @@ static PyObject *Quaternion_mul(PyObject *q1, PyObject *q2)
BLI_assert(!"internal error");
}
PyErr_Format(PyExc_TypeError, "Quaternion multiplication: not supported between '%.200s' and '%.200s' types", Py_TYPE(q1)->tp_name, Py_TYPE(q2)->tp_name);
PyErr_Format(PyExc_TypeError,
"Quaternion multiplication: "
"not supported between '%.200s' and '%.200s' types",
Py_TYPE(q1)->tp_name, Py_TYPE(q2)->tp_name);
return NULL;
}
@@ -861,7 +886,8 @@ static int Quaternion_setAngle(QuaternionObject *self, PyObject *value, void *UN
angle= PyFloat_AsDouble(value);
if(angle==-1.0 && PyErr_Occurred()) { /* parsed item not a number */
PyErr_SetString(PyExc_TypeError, "quaternion.angle = value: float expected");
PyErr_SetString(PyExc_TypeError,
"quaternion.angle = value: float expected");
return -1;
}
@@ -942,7 +968,9 @@ static PyObject *Quaternion_new(PyTypeObject *type, PyObject *args, PyObject *kw
float quat[QUAT_SIZE]= {0.0f, 0.0f, 0.0f, 0.0f};
if(kwds && PyDict_Size(kwds)) {
PyErr_SetString(PyExc_TypeError, "mathutils.Quaternion(): takes no keyword args");
PyErr_SetString(PyExc_TypeError,
"mathutils.Quaternion(): "
"takes no keyword args");
return NULL;
}
@@ -1114,8 +1142,7 @@ PyObject *newQuaternionObject(float *quat, int type, PyTypeObject *base_type)
self->wrapped = Py_NEW;
}
else {
PyErr_SetString(PyExc_RuntimeError, "Quaternion(): invalid type");
return NULL;
Py_FatalError("Quaternion(): invalid type!");
}
}
return (PyObject *) self;

0
source/blender/python/generic/mathutils_Quaternion.h → source/blender/python/mathutils/mathutils_Quaternion.h
View File

227
source/blender/python/generic/mathutils_Vector.c → source/blender/python/mathutils/mathutils_Vector.c
View File

@@ -34,7 +34,6 @@
#include "mathutils.h"
#include "BLI_blenlib.h"
#include "BLI_math.h"
#include "BLI_utildefines.h"
@@ -66,7 +65,9 @@ static PyObject *Vector_new(PyTypeObject *type, PyObject *args, PyObject *UNUSED
return NULL;
break;
default:
PyErr_SetString(PyExc_TypeError, "mathutils.Vector(): more then a single arg given");
PyErr_SetString(PyExc_TypeError,
"mathutils.Vector(): "
"more then a single arg given");
return NULL;
}
return newVectorObject(vec, size, Py_NEW, type);
@@ -156,17 +157,23 @@ PyDoc_STRVAR(Vector_resize_2d_doc,
static PyObject *Vector_resize_2d(VectorObject *self)
{
if(self->wrapped==Py_WRAP) {
PyErr_SetString(PyExc_TypeError, "vector.resize_2d(): cannot resize wrapped data - only python vectors");
PyErr_SetString(PyExc_TypeError,
"vector.resize_2d(): "
"cannot resize wrapped data - only python vectors");
return NULL;
}
if(self->cb_user) {
PyErr_SetString(PyExc_TypeError, "vector.resize_2d(): cannot resize a vector that has an owner");
PyErr_SetString(PyExc_TypeError,
"vector.resize_2d(): "
"cannot resize a vector that has an owner");
return NULL;
}
self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 2));
if(self->vec == NULL) {
PyErr_SetString(PyExc_MemoryError, "vector.resize_2d(): problem allocating pointer space");
PyErr_SetString(PyExc_MemoryError,
"vector.resize_2d(): "
"problem allocating pointer space");
return NULL;
}
@@ -185,17 +192,23 @@ PyDoc_STRVAR(Vector_resize_3d_doc,
static PyObject *Vector_resize_3d(VectorObject *self)
{
if (self->wrapped==Py_WRAP) {
PyErr_SetString(PyExc_TypeError, "vector.resize_3d(): cannot resize wrapped data - only python vectors");
PyErr_SetString(PyExc_TypeError,
"vector.resize_3d(): "
"cannot resize wrapped data - only python vectors");
return NULL;
}
if(self->cb_user) {
PyErr_SetString(PyExc_TypeError, "vector.resize_3d(): cannot resize a vector that has an owner");
PyErr_SetString(PyExc_TypeError,
"vector.resize_3d(): "
"cannot resize a vector that has an owner");
return NULL;
}
self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 3));
if(self->vec == NULL) {
PyErr_SetString(PyExc_MemoryError, "vector.resize_3d(): problem allocating pointer space");
PyErr_SetString(PyExc_MemoryError,
"vector.resize_3d(): "
"problem allocating pointer space");
return NULL;
}
@@ -217,17 +230,23 @@ PyDoc_STRVAR(Vector_resize_4d_doc,
static PyObject *Vector_resize_4d(VectorObject *self)
{
if(self->wrapped==Py_WRAP) {
PyErr_SetString(PyExc_TypeError, "vector.resize_4d(): cannot resize wrapped data - only python vectors");
PyErr_SetString(PyExc_TypeError,
"vector.resize_4d(): "
"cannot resize wrapped data - only python vectors");
return NULL;
}
if(self->cb_user) {
PyErr_SetString(PyExc_TypeError, "vector.resize_4d(): cannot resize a vector that has an owner");
PyErr_SetString(PyExc_TypeError,
"vector.resize_4d(): "
"cannot resize a vector that has an owner");
return NULL;
}
self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 4));
if(self->vec == NULL) {
PyErr_SetString(PyExc_MemoryError, "vector.resize_4d(): problem allocating pointer space");
PyErr_SetString(PyExc_MemoryError,
"vector.resize_4d(): "
"problem allocating pointer space");
return NULL;
}
@@ -333,7 +352,9 @@ static PyObject *Vector_to_tuple(VectorObject *self, PyObject *args)
return NULL;
if(ndigits > 22 || ndigits < 0) {
PyErr_SetString(PyExc_ValueError, "vector.to_tuple(ndigits): ndigits must be between 0 and 21");
PyErr_SetString(PyExc_ValueError,
"vector.to_tuple(ndigits): "
"ndigits must be between 0 and 21");
return NULL;
}
@@ -368,7 +389,9 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args)
return NULL;
if (self->size != 3) {
PyErr_SetString(PyExc_TypeError, "only for 3D vectors");
PyErr_SetString(PyExc_TypeError,
"vector.to_track_quat(): "
"only for 3D vectors");
return NULL;
}
@@ -376,6 +399,8 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args)
return NULL;
if (strack) {
const char *axis_err_msg= "only X, -X, Y, -Y, Z or -Z for track axis";
if (strlen(strack) == 2) {
if (strack[0] == '-') {
switch(strack[1]) {
@@ -389,12 +414,12 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args)
track = 5;
break;
default:
PyErr_SetString(PyExc_ValueError, "only X, -X, Y, -Y, Z or -Z for track axis");
PyErr_SetString(PyExc_ValueError, axis_err_msg);
return NULL;
}
}
else {
PyErr_SetString(PyExc_ValueError, "only X, -X, Y, -Y, Z or -Z for track axis");
PyErr_SetString(PyExc_ValueError, axis_err_msg);
return NULL;
}
}
@@ -411,17 +436,18 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args)
track = 2;
break;
default:
PyErr_SetString(PyExc_ValueError, "only X, -X, Y, -Y, Z or -Z for track axis");
PyErr_SetString(PyExc_ValueError, axis_err_msg);
return NULL;
}
}
else {
PyErr_SetString(PyExc_ValueError, "only X, -X, Y, -Y, Z or -Z for track axis");
PyErr_SetString(PyExc_ValueError, axis_err_msg);
return NULL;
}
}
if (sup) {
const char *axis_err_msg= "only X, Y or Z for up axis";
if (strlen(sup) == 1) {
switch(*sup) {
case 'X':
@@ -434,18 +460,19 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args)
up = 2;
break;
default:
PyErr_SetString(PyExc_ValueError, "only X, Y or Z for up axis");
PyErr_SetString(PyExc_ValueError, axis_err_msg);
return NULL;
}
}
else {
PyErr_SetString(PyExc_ValueError, "only X, Y or Z for up axis");
PyErr_SetString(PyExc_ValueError, axis_err_msg);
return NULL;
}
}
if (track == up) {
PyErr_SetString(PyExc_ValueError, "Can't have the same axis for track and up");
PyErr_SetString(PyExc_ValueError,
"Can't have the same axis for track and up");
return NULL;
}
@@ -604,7 +631,9 @@ static PyObject *Vector_angle(VectorObject *self, PyObject *args)
return fallback;
}
else {
PyErr_SetString(PyExc_ValueError, "vector.angle(other): zero length vectors have no valid angle");
PyErr_SetString(PyExc_ValueError,
"vector.angle(other): "
"zero length vectors have no valid angle");
return NULL;
}
}
@@ -636,7 +665,9 @@ static PyObject *Vector_rotation_difference(VectorObject *self, PyObject *value)
float quat[4], vec_a[3], vec_b[3];
if(self->size < 3) {
PyErr_SetString(PyExc_AttributeError, "vec.difference(value): expects both vectors to be size 3 or 4");
PyErr_SetString(PyExc_ValueError,
"vec.difference(value): "
"expects both vectors to be size 3 or 4");
return NULL;
}
@@ -750,7 +781,8 @@ static PyObject *Vector_rotate(VectorObject *self, PyObject *value)
return NULL;
if(self->size < 3) {
PyErr_SetString(PyExc_ValueError, "Vector must be 3D or 4D");
PyErr_SetString(PyExc_ValueError,
"Vector must be 3D or 4D");
return NULL;
}
@@ -804,8 +836,15 @@ static PyObject *vector_item_internal(VectorObject *self, int i, const int is_at
if(i<0) i= self->size-i;
if(i < 0 || i >= self->size) {
if(is_attr) PyErr_Format(PyExc_AttributeError,"vector.%c: unavailable on %dd vector", *(((char *)"xyzw") + i), self->size);
else PyErr_SetString(PyExc_IndexError,"vector[index]: out of range");
if(is_attr) {
PyErr_Format(PyExc_AttributeError,
"vector.%c: unavailable on %dd vector",
*(((char *)"xyzw") + i), self->size);
}
else {
PyErr_SetString(PyExc_IndexError,
"vector[index]: out of range");
}
return NULL;
}
@@ -824,15 +863,25 @@ static int vector_ass_item_internal(VectorObject *self, int i, PyObject *value,
{
float scalar;
if((scalar=PyFloat_AsDouble(value))==-1.0f && PyErr_Occurred()) { /* parsed item not a number */
PyErr_SetString(PyExc_TypeError, "vector[index] = x: index argument not a number");
PyErr_SetString(PyExc_TypeError,
"vector[index] = x: "
"index argument not a number");
return -1;
}
if(i<0) i= self->size-i;
if(i < 0 || i >= self->size){
if(is_attr) PyErr_Format(PyExc_AttributeError,"vector.%c = x: unavailable on %dd vector", *(((char *)"xyzw") + i), self->size);
else PyErr_SetString(PyExc_IndexError, "vector[index] = x: assignment index out of range");
if(is_attr) {
PyErr_Format(PyExc_AttributeError,
"vector.%c = x: unavailable on %dd vector",
*(((char *)"xyzw") + i), self->size);
}
else {
PyErr_SetString(PyExc_IndexError,
"vector[index] = x: "
"assignment index out of range");
}
return -1;
}
self->vec[i] = scalar;
@@ -904,7 +953,9 @@ static PyObject *Vector_add(PyObject *v1, PyObject *v2)
float vec[MAX_DIMENSIONS];
if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
PyErr_SetString(PyExc_AttributeError, "Vector addition: arguments not valid for this operation");
PyErr_SetString(PyExc_AttributeError,
"Vector addition: "
"arguments not valid for this operation");
return NULL;
}
vec1 = (VectorObject*)v1;
@@ -915,7 +966,9 @@ static PyObject *Vector_add(PyObject *v1, PyObject *v2)
/*VECTOR + VECTOR*/
if(vec1->size != vec2->size) {
PyErr_SetString(PyExc_AttributeError, "Vector addition: vectors must have the same dimensions for this operation");
PyErr_SetString(PyExc_AttributeError,
"Vector addition: "
"vectors must have the same dimensions for this operation");
return NULL;
}
@@ -930,14 +983,18 @@ static PyObject *Vector_iadd(PyObject *v1, PyObject *v2)
VectorObject *vec1 = NULL, *vec2 = NULL;
if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
PyErr_SetString(PyExc_AttributeError, "Vector addition: arguments not valid for this operation");
PyErr_SetString(PyExc_AttributeError,
"Vector addition: "
"arguments not valid for this operation");
return NULL;
}
vec1 = (VectorObject*)v1;
vec2 = (VectorObject*)v2;
if(vec1->size != vec2->size) {
PyErr_SetString(PyExc_AttributeError, "Vector addition: vectors must have the same dimensions for this operation");
PyErr_SetString(PyExc_AttributeError,
"Vector addition: "
"vectors must have the same dimensions for this operation");
return NULL;
}
@@ -958,7 +1015,9 @@ static PyObject *Vector_sub(PyObject *v1, PyObject *v2)
float vec[MAX_DIMENSIONS];
if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
PyErr_SetString(PyExc_AttributeError, "Vector subtraction: arguments not valid for this operation");
PyErr_SetString(PyExc_AttributeError,
"Vector subtraction: "
"arguments not valid for this operation");
return NULL;
}
vec1 = (VectorObject*)v1;
@@ -968,7 +1027,9 @@ static PyObject *Vector_sub(PyObject *v1, PyObject *v2)
return NULL;
if(vec1->size != vec2->size) {
PyErr_SetString(PyExc_AttributeError, "Vector subtraction: vectors must have the same dimensions for this operation");
PyErr_SetString(PyExc_AttributeError,
"Vector subtraction: "
"vectors must have the same dimensions for this operation");
return NULL;
}
@@ -983,14 +1044,18 @@ static PyObject *Vector_isub(PyObject *v1, PyObject *v2)
VectorObject *vec1= NULL, *vec2= NULL;
if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
PyErr_SetString(PyExc_AttributeError, "Vector subtraction: arguments not valid for this operation");
PyErr_SetString(PyExc_AttributeError,
"Vector subtraction: "
"arguments not valid for this operation");
return NULL;
}
vec1 = (VectorObject*)v1;
vec2 = (VectorObject*)v2;
if(vec1->size != vec2->size) {
PyErr_SetString(PyExc_AttributeError, "Vector subtraction: vectors must have the same dimensions for this operation");
PyErr_SetString(PyExc_AttributeError,
"Vector subtraction: "
"vectors must have the same dimensions for this operation");
return NULL;
}
@@ -1027,7 +1092,10 @@ static int column_vector_multiplication(float rvec[MAX_DIMENSIONS], VectorObject
vec_cpy[3] = 1.0f;
}
else {
PyErr_SetString(PyExc_AttributeError, "matrix * vector: matrix.row_size and len(vector) must be the same, except for 3D vector * 4x4 matrix.");
PyErr_SetString(PyExc_TypeError,
"matrix * vector: "
"matrix.row_size and len(vector) must be the same, "
"except for 3D vector * 4x4 matrix.");
return -1;
}
}
@@ -1077,7 +1145,9 @@ static PyObject *Vector_mul(PyObject *v1, PyObject *v2)
double dot = 0.0f;
if(vec1->size != vec2->size) {
PyErr_SetString(PyExc_AttributeError, "Vector multiplication: vectors must have the same dimensions for this operation");
PyErr_SetString(PyExc_ValueError,
"Vector multiplication: "
"vectors must have the same dimensions for this operation");
return NULL;
}
@@ -1105,7 +1175,9 @@ static PyObject *Vector_mul(PyObject *v1, PyObject *v2)
float tvec[3];
if(vec1->size != 3) {
PyErr_SetString(PyExc_TypeError, "Vector multiplication: only 3D vector rotations (with quats) currently supported");
PyErr_SetString(PyExc_ValueError,
"Vector multiplication: "
"only 3D vector rotations (with quats) currently supported");
return NULL;
}
if(BaseMath_ReadCallback(quat2) == -1) {
@@ -1128,7 +1200,10 @@ static PyObject *Vector_mul(PyObject *v1, PyObject *v2)
BLI_assert(!"internal error");
}
PyErr_Format(PyExc_TypeError, "Vector multiplication: not supported between '%.200s' and '%.200s' types", Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
PyErr_Format(PyExc_TypeError,
"Vector multiplication: "
"not supported between '%.200s' and '%.200s' types",
Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
return NULL;
}
@@ -1158,7 +1233,9 @@ static PyObject *Vector_imul(PyObject *v1, PyObject *v2)
QuaternionObject *quat2 = (QuaternionObject*)v2;
if(vec->size != 3) {
PyErr_SetString(PyExc_TypeError, "Vector multiplication: only 3D vector rotations (with quats) currently supported");
PyErr_SetString(PyExc_ValueError,
"Vector multiplication: "
"only 3D vector rotations (with quats) currently supported");
return NULL;
}
@@ -1171,7 +1248,9 @@ static PyObject *Vector_imul(PyObject *v1, PyObject *v2)
mul_vn_fl(vec->vec, vec->size, scalar);
}
else {
PyErr_SetString(PyExc_TypeError, "Vector multiplication: arguments not acceptable for this operation");
PyErr_SetString(PyExc_TypeError,
"Vector multiplication: "
"arguments not acceptable for this operation");
return NULL;
}
@@ -1188,7 +1267,9 @@ static PyObject *Vector_div(PyObject *v1, PyObject *v2)
VectorObject *vec1 = NULL;
if(!VectorObject_Check(v1)) { /* not a vector */
PyErr_SetString(PyExc_TypeError, "Vector division: Vector must be divided by a float");
PyErr_SetString(PyExc_TypeError,
"Vector division: "
"Vector must be divided by a float");
return NULL;
}
vec1 = (VectorObject*)v1; /* vector */
@@ -1197,12 +1278,16 @@ static PyObject *Vector_div(PyObject *v1, PyObject *v2)
return NULL;
if((scalar=PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
PyErr_SetString(PyExc_TypeError, "Vector division: Vector must be divided by a float");
PyErr_SetString(PyExc_TypeError,
"Vector division: "
"Vector must be divided by a float");
return NULL;
}
if(scalar==0.0f) {
PyErr_SetString(PyExc_ZeroDivisionError, "Vector division: divide by zero error");
PyErr_SetString(PyExc_ZeroDivisionError,
"Vector division: "
"divide by zero error");
return NULL;
}
@@ -1223,12 +1308,16 @@ static PyObject *Vector_idiv(PyObject *v1, PyObject *v2)
return NULL;
if((scalar=PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
PyErr_SetString(PyExc_TypeError, "Vector division: Vector must be divided by a float");
PyErr_SetString(PyExc_TypeError,
"Vector division: "
"Vector must be divided by a float");
return NULL;
}
if(scalar==0.0f) {
PyErr_SetString(PyExc_ZeroDivisionError, "Vector division: divide by zero error");
PyErr_SetString(PyExc_ZeroDivisionError,
"Vector division: "
"divide by zero error");
return NULL;
}
for(i = 0; i < vec1->size; i++) {
@@ -1394,12 +1483,15 @@ static PyObject *Vector_subscript(VectorObject* self, PyObject* item)
return Vector_slice(self, start, stop);
}
else {
PyErr_SetString(PyExc_TypeError, "slice steps not supported with vectors");
PyErr_SetString(PyExc_IndexError,
"slice steps not supported with vectors");
return NULL;
}
}
else {
PyErr_Format(PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
PyErr_Format(PyExc_TypeError,
"vector indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return NULL;
}
}
@@ -1423,12 +1515,15 @@ static int Vector_ass_subscript(VectorObject* self, PyObject* item, PyObject* va
if (step == 1)
return Vector_ass_slice(self, start, stop, value);
else {
PyErr_SetString(PyExc_TypeError, "slice steps not supported with vectors");
PyErr_SetString(PyExc_IndexError,
"slice steps not supported with vectors");
return -1;
}
}
else {
PyErr_Format(PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
PyErr_Format(PyExc_TypeError,
"vector indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return -1;
}
}
@@ -1517,12 +1612,14 @@ static int Vector_setLength(VectorObject *self, PyObject *value)
return -1;
if((param=PyFloat_AsDouble(value)) == -1.0 && PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, "length must be set to a number");
PyErr_SetString(PyExc_TypeError,
"length must be set to a number");
return -1;
}
if (param < 0.0) {
PyErr_SetString(PyExc_TypeError, "cannot set a vectors length to a negative value");
PyErr_SetString(PyExc_ValueError,
"cannot set a vectors length to a negative value");
return -1;
}
if (param == 0.0) {
@@ -1573,7 +1670,9 @@ static PyObject *Vector_getSwizzle(VectorObject *self, void *closure)
{
axis_from = swizzleClosure & SWIZZLE_AXIS;
if(axis_from >= self->size) {
PyErr_SetString(PyExc_AttributeError, "Error: vector does not have specified axis");
PyErr_SetString(PyExc_AttributeError,
"Vector swizzle: "
"specified axis not present");
return NULL;
}
@@ -1615,12 +1714,13 @@ static int Vector_setSwizzle(VectorObject *self, PyObject *value, void *closure)
swizzles defined for axes z and w, but they would be invalid. */
swizzleClosure = GET_INT_FROM_POINTER(closure);
axis_from= 0;
while (swizzleClosure & SWIZZLE_VALID_AXIS)
{
while (swizzleClosure & SWIZZLE_VALID_AXIS) {
axis_to = swizzleClosure & SWIZZLE_AXIS;
if (axis_to >= self->size)
{
PyErr_SetString(PyExc_AttributeError, "Error: vector does not have specified axis");
PyErr_SetString(PyExc_AttributeError,
"Vector swizzle: "
"specified axis not present");
return -1;
}
swizzleClosure = swizzleClosure >> SWIZZLE_BITS_PER_AXIS;
@@ -1639,7 +1739,8 @@ static int Vector_setSwizzle(VectorObject *self, PyObject *value, void *closure)
}
if(axis_from != size_from) {
PyErr_SetString(PyExc_AttributeError, "Error: vector size does not match swizzle");
PyErr_SetString(PyExc_AttributeError,
"Vector swizzle: size does not match swizzle");
return -1;
}
@@ -2071,7 +2172,9 @@ static int row_vector_multiplication(float rvec[4], VectorObject* vec, MatrixObj
if(mat->colSize != vec_size){
if(mat->colSize == 4 && vec_size != 3){
PyErr_SetString(PyExc_AttributeError, "vector * matrix: matrix column size and the vector size must be the same");
PyErr_SetString(PyExc_ValueError,
"vector * matrix: matrix column size "
"and the vector size must be the same");
return -1;
}
else {
@@ -2252,7 +2355,8 @@ PyObject *newVectorObject(float *vec, const int size, const int type, PyTypeObje
VectorObject *self;
if(size > 4 || size < 2) {
PyErr_SetString(PyExc_RuntimeError, "Vector(): invalid size");
PyErr_SetString(PyExc_RuntimeError,
"Vector(): invalid size");
return NULL;
}
@@ -2284,8 +2388,7 @@ PyObject *newVectorObject(float *vec, const int size, const int type, PyTypeObje
self->wrapped = Py_NEW;
}
else {
PyErr_SetString(PyExc_RuntimeError, "Vector(): invalid type");
return NULL;
Py_FatalError("Vector(): invalid type!");
}
}
return (PyObject *) self;

0
source/blender/python/generic/mathutils_Vector.h → source/blender/python/mathutils/mathutils_Vector.h
View File

825
source/blender/python/generic/mathutils_geometry.c → source/blender/python/mathutils/mathutils_geometry.c
View File

@@ -1,4 +1,4 @@
/*
/*
* $Id$
*
* ***** BEGIN GPL LICENSE BLOCK *****
@@ -37,16 +37,16 @@
#include "mathutils_geometry.h"
/* Used for PolyFill */
#include "MEM_guardedalloc.h"
#ifndef MATH_STANDALONE /* define when building outside blender */
# include "MEM_guardedalloc.h"
# include "BLI_blenlib.h"
# include "BLI_boxpack2d.h"
# include "BKE_displist.h"
# include "BKE_curve.h"
#endif
#include "BLI_blenlib.h"
#include "BLI_boxpack2d.h"
#include "BLI_math.h"
#include "BLI_utildefines.h"
#include "BKE_displist.h"
#include "BKE_curve.h"
#define SWAP_FLOAT(a, b, tmp) tmp=a; a=b; b=tmp
#define eps 0.000001
@@ -90,7 +90,8 @@ static PyObject *M_Geometry_intersect_ray_tri(PyObject *UNUSED(self), PyObject*
return NULL;
}
if(vec1->size != 3 || vec2->size != 3 || vec3->size != 3 || ray->size != 3 || ray_off->size != 3) {
PyErr_SetString(PyExc_ValueError, "only 3D vectors for all parameters");
PyErr_SetString(PyExc_ValueError,
"only 3D vectors for all parameters");
return NULL;
}
@@ -177,7 +178,8 @@ static PyObject *M_Geometry_intersect_line_line(PyObject *UNUSED(self), PyObject
return NULL;
}
if(vec1->size != vec2->size || vec1->size != vec3->size || vec3->size != vec2->size) {
PyErr_SetString(PyExc_ValueError,"vectors must be of the same size");
PyErr_SetString(PyExc_ValueError,
"vectors must be of the same size");
return NULL;
}
@@ -225,7 +227,8 @@ static PyObject *M_Geometry_intersect_line_line(PyObject *UNUSED(self), PyObject
}
}
else {
PyErr_SetString(PyExc_ValueError, "2D/3D vectors only");
PyErr_SetString(PyExc_ValueError,
"2D/3D vectors only");
return NULL;
}
}
@@ -259,11 +262,13 @@ static PyObject *M_Geometry_normal(PyObject *UNUSED(self), PyObject* args)
return NULL;
}
if(vec1->size != vec2->size || vec1->size != vec3->size) {
PyErr_SetString(PyExc_ValueError, "vectors must be of the same size");
PyErr_SetString(PyExc_ValueError,
"vectors must be of the same size");
return NULL;
}
if(vec1->size < 3) {
PyErr_SetString(PyExc_ValueError, "2D vectors unsupported");
PyErr_SetString(PyExc_ValueError,
"2D vectors unsupported");
return NULL;
}
@@ -277,11 +282,13 @@ static PyObject *M_Geometry_normal(PyObject *UNUSED(self), PyObject* args)
return NULL;
}
if(vec1->size != vec2->size || vec1->size != vec3->size || vec1->size != vec4->size) {
PyErr_SetString(PyExc_ValueError,"vectors must be of the same size");
PyErr_SetString(PyExc_ValueError,
"vectors must be of the same size");
return NULL;
}
if(vec1->size < 3) {
PyErr_SetString(PyExc_ValueError, "2D vectors unsupported");
PyErr_SetString(PyExc_ValueError,
"2D vectors unsupported");
return NULL;
}
@@ -318,7 +325,8 @@ static PyObject *M_Geometry_area_tri(PyObject *UNUSED(self), PyObject* args)
}
if(vec1->size != vec2->size || vec1->size != vec3->size) {
PyErr_SetString(PyExc_ValueError, "vectors must be of the same size");
PyErr_SetString(PyExc_ValueError,
"vectors must be of the same size");
return NULL;
}
@@ -332,131 +340,12 @@ static PyObject *M_Geometry_area_tri(PyObject *UNUSED(self), PyObject* args)
return PyFloat_FromDouble(area_tri_v2(vec1->vec, vec2->vec, vec3->vec));
}
else {
PyErr_SetString(PyExc_ValueError, "only 2D,3D vectors are supported");
PyErr_SetString(PyExc_ValueError,
"only 2D,3D vectors are supported");
return NULL;
}
}
/*----------------------------------geometry.PolyFill() -------------------*/
PyDoc_STRVAR(M_Geometry_tesselate_polygon_doc,
".. function:: tesselate_polygon(veclist_list)\n"
"\n"
" Takes a list of polylines (each point a vector) and returns the point indices for a polyline filled with triangles.\n"
"\n"
" :arg veclist_list: list of polylines\n"
" :rtype: list\n"
);
/* PolyFill function, uses Blenders scanfill to fill multiple poly lines */
static PyObject *M_Geometry_tesselate_polygon(PyObject *UNUSED(self), PyObject *polyLineSeq)
{
PyObject *tri_list; /*return this list of tri's */
PyObject *polyLine, *polyVec;
int i, len_polylines, len_polypoints, ls_error= 0;
/* display listbase */
ListBase dispbase={NULL, NULL};
DispList *dl;
float *fp; /*pointer to the array of malloced dl->verts to set the points from the vectors */
int index, *dl_face, totpoints=0;
if(!PySequence_Check(polyLineSeq)) {
PyErr_SetString(PyExc_TypeError, "expected a sequence of poly lines");
return NULL;
}
len_polylines= PySequence_Size(polyLineSeq);
for(i= 0; i < len_polylines; ++i) {
polyLine= PySequence_GetItem(polyLineSeq, i);
if (!PySequence_Check(polyLine)) {
freedisplist(&dispbase);
Py_XDECREF(polyLine); /* may be null so use Py_XDECREF*/
PyErr_SetString(PyExc_TypeError, "One or more of the polylines is not a sequence of mathutils.Vector's");
return NULL;
}
len_polypoints= PySequence_Size(polyLine);
if (len_polypoints>0) { /* dont bother adding edges as polylines */
#if 0
if (EXPP_check_sequence_consistency(polyLine, &vector_Type) != 1) {
freedisplist(&dispbase);
Py_DECREF(polyLine);
PyErr_SetString(PyExc_TypeError, "A point in one of the polylines is not a mathutils.Vector type");
return NULL;
}
#endif
dl= MEM_callocN(sizeof(DispList), "poly disp");
BLI_addtail(&dispbase, dl);
dl->type= DL_INDEX3;
dl->nr= len_polypoints;
dl->type= DL_POLY;
dl->parts= 1; /* no faces, 1 edge loop */
dl->col= 0; /* no material */
dl->verts= fp= MEM_callocN(sizeof(float)*3*len_polypoints, "dl verts");
dl->index= MEM_callocN(sizeof(int)*3*len_polypoints, "dl index");
for(index= 0; index<len_polypoints; ++index, fp+=3) {
polyVec= PySequence_GetItem(polyLine, index);
if(VectorObject_Check(polyVec)) {
if(BaseMath_ReadCallback((VectorObject *)polyVec) == -1)
ls_error= 1;
fp[0]= ((VectorObject *)polyVec)->vec[0];
fp[1]= ((VectorObject *)polyVec)->vec[1];
if(((VectorObject *)polyVec)->size > 2)
fp[2]= ((VectorObject *)polyVec)->vec[2];
else
fp[2]= 0.0f; /* if its a 2d vector then set the z to be zero */
}
else {
ls_error= 1;
}
totpoints++;
Py_DECREF(polyVec);
}
}
Py_DECREF(polyLine);
}
if(ls_error) {
freedisplist(&dispbase); /* possible some dl was allocated */
PyErr_SetString(PyExc_TypeError, "A point in one of the polylines is not a mathutils.Vector type");
return NULL;
}
else if (totpoints) {
/* now make the list to return */
filldisplist(&dispbase, &dispbase, 0);
/* The faces are stored in a new DisplayList
thats added to the head of the listbase */
dl= dispbase.first;
tri_list= PyList_New(dl->parts);
if(!tri_list) {
freedisplist(&dispbase);
PyErr_SetString(PyExc_RuntimeError, "geometry.PolyFill failed to make a new list");
return NULL;
}
index= 0;
dl_face= dl->index;
while(index < dl->parts) {
PyList_SET_ITEM(tri_list, index, Py_BuildValue("iii", dl_face[0], dl_face[1], dl_face[2]));
dl_face+= 3;
index++;
}
freedisplist(&dispbase);
}
else {
/* no points, do this so scripts dont barf */
freedisplist(&dispbase); /* possible some dl was allocated */
tri_list= PyList_New(0);
}
return tri_list;
}
PyDoc_STRVAR(M_Geometry_intersect_line_line_2d_doc,
".. function:: intersect_line_line_2d(lineA_p1, lineA_p2, lineB_p1, lineB_p2)\n"
@@ -522,7 +411,7 @@ static PyObject *M_Geometry_intersect_line_plane(PyObject *UNUSED(self), PyObjec
VectorObject *line_a, *line_b, *plane_co, *plane_no;
int no_flip= 0;
float isect[3];
if(!PyArg_ParseTuple(args, "O!O!O!O!|i:intersect_line_line_2d",
if(!PyArg_ParseTuple(args, "O!O!O!O!|i:intersect_line_plane",
&vector_Type, &line_a,
&vector_Type, &line_b,
&vector_Type, &plane_co,
@@ -541,7 +430,9 @@ static PyObject *M_Geometry_intersect_line_plane(PyObject *UNUSED(self), PyObjec
}
if(ELEM4(2, line_a->size, line_b->size, plane_co->size, plane_no->size)) {
PyErr_SetString(PyExc_RuntimeError, "geometry.intersect_line_plane(...) can't use 2D Vectors");
PyErr_SetString(PyExc_ValueError,
"geometry.intersect_line_plane(...): "
" can't use 2D Vectors");
return NULL;
}
@@ -553,6 +444,159 @@ static PyObject *M_Geometry_intersect_line_plane(PyObject *UNUSED(self), PyObjec
}
}
PyDoc_STRVAR(M_Geometry_intersect_line_sphere_doc,
".. function:: intersect_line_sphere(line_a, line_b, sphere_co, sphere_radius, clip=True)\n"
"\n"
" Takes a lines (as 2 vectors), a sphere as a point and a radius and\n"
" returns the intersection\n"
"\n"
" :arg line_a: First point of the first line\n"
" :type line_a: :class:`mathutils.Vector`\n"
" :arg line_b: Second point of the first line\n"
" :type line_b: :class:`mathutils.Vector`\n"
" :arg sphere_co: The center of the sphere\n"
" :type sphere_co: :class:`mathutils.Vector`\n"
" :arg sphere_radius: Radius of the sphere\n"
" :type sphere_radius: sphere_radius\n"
" :return: The intersection points as a pair of vectors or None when there is no intersection\n"
" :rtype: A tuple pair containing :class:`mathutils.Vector` or None\n"
);
static PyObject *M_Geometry_intersect_line_sphere(PyObject *UNUSED(self), PyObject* args)
{
VectorObject *line_a, *line_b, *sphere_co;
float sphere_radius;
int clip= TRUE;
float isect_a[3];
float isect_b[3];
if(!PyArg_ParseTuple(args, "O!O!O!f|i:intersect_line_sphere",
&vector_Type, &line_a,
&vector_Type, &line_b,
&vector_Type, &sphere_co,
&sphere_radius, &clip)
) {
return NULL;
}
if( BaseMath_ReadCallback(line_a) == -1 ||
BaseMath_ReadCallback(line_b) == -1 ||
BaseMath_ReadCallback(sphere_co) == -1
) {
return NULL;
}
if(ELEM3(2, line_a->size, line_b->size, sphere_co->size)) {
PyErr_SetString(PyExc_ValueError,
"geometry.intersect_line_sphere(...): "
" can't use 2D Vectors");
return NULL;
}
else {
short use_a= TRUE;
short use_b= TRUE;
float lambda;
PyObject *ret= PyTuple_New(2);
switch(isect_line_sphere_v3(line_a->vec, line_b->vec, sphere_co->vec, sphere_radius, isect_a, isect_b)) {
case 1:
if(!(!clip || (((lambda= line_point_factor_v3(isect_a, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_a= FALSE;
use_b= FALSE;
break;
case 2:
if(!(!clip || (((lambda= line_point_factor_v3(isect_a, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_a= FALSE;
if(!(!clip || (((lambda= line_point_factor_v3(isect_b, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_b= FALSE;
break;
default:
use_a= FALSE;
use_b= FALSE;
}
if(use_a) { PyTuple_SET_ITEM(ret, 0, newVectorObject(isect_a, 3, Py_NEW, NULL)); }
else { PyTuple_SET_ITEM(ret, 0, Py_None); Py_INCREF(Py_None); }
if(use_b) { PyTuple_SET_ITEM(ret, 1, newVectorObject(isect_b, 3, Py_NEW, NULL)); }
else { PyTuple_SET_ITEM(ret, 1, Py_None); Py_INCREF(Py_None); }
return ret;
}
}
/* keep in sync with M_Geometry_intersect_line_sphere */
PyDoc_STRVAR(M_Geometry_intersect_line_sphere_2d_doc,
".. function:: intersect_line_sphere_2d(line_a, line_b, sphere_co, sphere_radius, clip=True)\n"
"\n"
" Takes a lines (as 2 vectors), a sphere as a point and a radius and\n"
" returns the intersection\n"
"\n"
" :arg line_a: First point of the first line\n"
" :type line_a: :class:`mathutils.Vector`\n"
" :arg line_b: Second point of the first line\n"
" :type line_b: :class:`mathutils.Vector`\n"
" :arg sphere_co: The center of the sphere\n"
" :type sphere_co: :class:`mathutils.Vector`\n"
" :arg sphere_radius: Radius of the sphere\n"
" :type sphere_radius: sphere_radius\n"
" :return: The intersection points as a pair of vectors or None when there is no intersection\n"
" :rtype: A tuple pair containing :class:`mathutils.Vector` or None\n"
);
static PyObject *M_Geometry_intersect_line_sphere_2d(PyObject *UNUSED(self), PyObject* args)
{
VectorObject *line_a, *line_b, *sphere_co;
float sphere_radius;
int clip= TRUE;
float isect_a[3];
float isect_b[3];
if(!PyArg_ParseTuple(args, "O!O!O!f|i:intersect_line_sphere_2d",
&vector_Type, &line_a,
&vector_Type, &line_b,
&vector_Type, &sphere_co,
&sphere_radius, &clip)
) {
return NULL;
}
if( BaseMath_ReadCallback(line_a) == -1 ||
BaseMath_ReadCallback(line_b) == -1 ||
BaseMath_ReadCallback(sphere_co) == -1
) {
return NULL;
}
else {
short use_a= TRUE;
short use_b= TRUE;
float lambda;
PyObject *ret= PyTuple_New(2);
switch(isect_line_sphere_v2(line_a->vec, line_b->vec, sphere_co->vec, sphere_radius, isect_a, isect_b)) {
case 1:
if(!(!clip || (((lambda= line_point_factor_v2(isect_a, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_a= FALSE;
use_b= FALSE;
break;
case 2:
if(!(!clip || (((lambda= line_point_factor_v2(isect_a, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_a= FALSE;
if(!(!clip || (((lambda= line_point_factor_v2(isect_b, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_b= FALSE;
break;
default:
use_a= FALSE;
use_b= FALSE;
}
if(use_a) { PyTuple_SET_ITEM(ret, 0, newVectorObject(isect_a, 2, Py_NEW, NULL)); }
else { PyTuple_SET_ITEM(ret, 0, Py_None); Py_INCREF(Py_None); }
if(use_b) { PyTuple_SET_ITEM(ret, 1, newVectorObject(isect_b, 2, Py_NEW, NULL)); }
else { PyTuple_SET_ITEM(ret, 1, Py_None); Py_INCREF(Py_None); }
return ret;
}
}
PyDoc_STRVAR(M_Geometry_intersect_point_line_doc,
".. function:: intersect_point_line(pt, line_p1, line_p2)\n"
"\n"
@@ -674,181 +718,6 @@ static PyObject *M_Geometry_intersect_point_quad_2d(PyObject *UNUSED(self), PyOb
return PyLong_FromLong(isect_point_quad_v2(pt_vec->vec, quad_p1->vec, quad_p2->vec, quad_p3->vec, quad_p4->vec));
}
static int boxPack_FromPyObject(PyObject *value, boxPack **boxarray)
{
int len, i;
PyObject *list_item, *item_1, *item_2;
boxPack *box;
/* Error checking must already be done */
if(!PyList_Check(value)) {
PyErr_SetString(PyExc_TypeError, "can only back a list of [x, y, w, h]");
return -1;
}
len= PyList_Size(value);
(*boxarray)= MEM_mallocN(len*sizeof(boxPack), "boxPack box");
for(i= 0; i < len; i++) {
list_item= PyList_GET_ITEM(value, i);
if(!PyList_Check(list_item) || PyList_Size(list_item) < 4) {
MEM_freeN(*boxarray);
PyErr_SetString(PyExc_TypeError, "can only pack a list of [x, y, w, h]");
return -1;
}
box= (*boxarray)+i;
item_1= PyList_GET_ITEM(list_item, 2);
item_2= PyList_GET_ITEM(list_item, 3);
box->w= (float)PyFloat_AsDouble(item_1);
box->h= (float)PyFloat_AsDouble(item_2);
box->index= i;
if (box->w < 0.0f || box->h < 0.0f) {
MEM_freeN(*boxarray);
PyErr_SetString(PyExc_TypeError, "error parsing width and height values from list: [x, y, w, h], not numbers or below zero");
return -1;
}
/* verts will be added later */
}
return 0;
}
static void boxPack_ToPyObject(PyObject *value, boxPack **boxarray)
{
int len, i;
PyObject *list_item;
boxPack *box;
len= PyList_Size(value);
for(i= 0; i < len; i++) {
box= (*boxarray)+i;
list_item= PyList_GET_ITEM(value, box->index);
PyList_SET_ITEM(list_item, 0, PyFloat_FromDouble(box->x));
PyList_SET_ITEM(list_item, 1, PyFloat_FromDouble(box->y));
}
MEM_freeN(*boxarray);
}
PyDoc_STRVAR(M_Geometry_box_pack_2d_doc,
".. function:: box_pack_2d(boxes)\n"
"\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"
" :type boxes: list\n"
" :return: the width and height of the packed bounding box\n"
" :rtype: tuple, pair of floats\n"
);
static PyObject *M_Geometry_box_pack_2d(PyObject *UNUSED(self), PyObject *boxlist)
{
float tot_width= 0.0f, tot_height= 0.0f;
int len;
PyObject *ret;
if(!PyList_Check(boxlist)) {
PyErr_SetString(PyExc_TypeError, "expected a list of boxes [[x, y, w, h], ... ]");
return NULL;
}
len= PyList_GET_SIZE(boxlist);
if (len) {
boxPack *boxarray= NULL;
if(boxPack_FromPyObject(boxlist, &boxarray) == -1) {
return NULL; /* exception set */
}
/* Non Python function */
boxPack2D(boxarray, len, &tot_width, &tot_height);
boxPack_ToPyObject(boxlist, &boxarray);
}
ret= PyTuple_New(2);
PyTuple_SET_ITEM(ret, 0, PyFloat_FromDouble(tot_width));
PyTuple_SET_ITEM(ret, 1, PyFloat_FromDouble(tot_width));
return ret;
}
PyDoc_STRVAR(M_Geometry_interpolate_bezier_doc,
".. function:: interpolate_bezier(knot1, handle1, handle2, knot2, resolution)\n"
"\n"
" Interpolate a bezier spline segment.\n"
"\n"
" :arg knot1: First bezier spline point.\n"
" :type knot1: :class:`mathutils.Vector`\n"
" :arg handle1: First bezier spline handle.\n"
" :type handle1: :class:`mathutils.Vector`\n"
" :arg handle2: Second bezier spline handle.\n"
" :type handle2: :class:`mathutils.Vector`\n"
" :arg knot2: Second bezier spline point.\n"
" :type knot2: :class:`mathutils.Vector`\n"
" :arg resolution: Number of points to return.\n"
" :type resolution: int\n"
" :return: The interpolated points\n"
" :rtype: list of :class:`mathutils.Vector`'s\n"
);
static PyObject *M_Geometry_interpolate_bezier(PyObject *UNUSED(self), PyObject* args)
{
VectorObject *vec_k1, *vec_h1, *vec_k2, *vec_h2;
int resolu;
int dims;
int i;
float *coord_array, *fp;
PyObject *list;
float k1[4]= {0.0, 0.0, 0.0, 0.0};
float h1[4]= {0.0, 0.0, 0.0, 0.0};
float k2[4]= {0.0, 0.0, 0.0, 0.0};
float h2[4]= {0.0, 0.0, 0.0, 0.0};
if(!PyArg_ParseTuple(args, "O!O!O!O!i:interpolate_bezier",
&vector_Type, &vec_k1,
&vector_Type, &vec_h1,
&vector_Type, &vec_h2,
&vector_Type, &vec_k2, &resolu)
) {
return NULL;
}
if(resolu <= 1) {
PyErr_SetString(PyExc_ValueError, "resolution must be 2 or over");
return NULL;
}
if(BaseMath_ReadCallback(vec_k1) == -1 || BaseMath_ReadCallback(vec_h1) == -1 || BaseMath_ReadCallback(vec_k2) == -1 || BaseMath_ReadCallback(vec_h2) == -1)
return NULL;
dims= MAX4(vec_k1->size, vec_h1->size, vec_h2->size, vec_k2->size);
for(i=0; i < vec_k1->size; i++) k1[i]= vec_k1->vec[i];
for(i=0; i < vec_h1->size; i++) h1[i]= vec_h1->vec[i];
for(i=0; i < vec_k2->size; i++) k2[i]= vec_k2->vec[i];
for(i=0; i < vec_h2->size; i++) h2[i]= vec_h2->vec[i];
coord_array= MEM_callocN(dims * (resolu) * sizeof(float), "interpolate_bezier");
for(i=0; i<dims; i++) {
forward_diff_bezier(k1[i], h1[i], h2[i], k2[i], coord_array+i, resolu-1, sizeof(float)*dims);
}
list= PyList_New(resolu);
fp= coord_array;
for(i=0; i<resolu; i++, fp= fp+dims) {
PyList_SET_ITEM(list, i, newVectorObject(fp, dims, Py_NEW, NULL));
}
MEM_freeN(coord_array);
return list;
}
PyDoc_STRVAR(M_Geometry_barycentric_transform_doc,
".. function:: barycentric_transform(point, tri_a1, tri_a2, tri_a3, tri_b1, tri_b2, tri_b3)\n"
"\n"
@@ -898,7 +767,8 @@ static PyObject *M_Geometry_barycentric_transform(PyObject *UNUSED(self), PyObje
vec_t2_tar->size != 3 ||
vec_t3_tar->size != 3)
{
PyErr_SetString(PyExc_ValueError, "One of more of the vector arguments wasnt a 3D vector");
PyErr_SetString(PyExc_ValueError,
"One of more of the vector arguments wasn't a 3D vector");
return NULL;
}
@@ -909,6 +779,321 @@ static PyObject *M_Geometry_barycentric_transform(PyObject *UNUSED(self), PyObje
return newVectorObject(vec, 3, Py_NEW, NULL);
}
#ifndef MATH_STANDALONE
PyDoc_STRVAR(M_Geometry_interpolate_bezier_doc,
".. function:: interpolate_bezier(knot1, handle1, handle2, knot2, resolution)\n"
"\n"
" Interpolate a bezier spline segment.\n"
"\n"
" :arg knot1: First bezier spline point.\n"
" :type knot1: :class:`mathutils.Vector`\n"
" :arg handle1: First bezier spline handle.\n"
" :type handle1: :class:`mathutils.Vector`\n"
" :arg handle2: Second bezier spline handle.\n"
" :type handle2: :class:`mathutils.Vector`\n"
" :arg knot2: Second bezier spline point.\n"
" :type knot2: :class:`mathutils.Vector`\n"
" :arg resolution: Number of points to return.\n"
" :type resolution: int\n"
" :return: The interpolated points\n"
" :rtype: list of :class:`mathutils.Vector`'s\n"
);
static PyObject *M_Geometry_interpolate_bezier(PyObject *UNUSED(self), PyObject* args)
{
VectorObject *vec_k1, *vec_h1, *vec_k2, *vec_h2;
int resolu;
int dims;
int i;
float *coord_array, *fp;
PyObject *list;
float k1[4]= {0.0, 0.0, 0.0, 0.0};
float h1[4]= {0.0, 0.0, 0.0, 0.0};
float k2[4]= {0.0, 0.0, 0.0, 0.0};
float h2[4]= {0.0, 0.0, 0.0, 0.0};
if(!PyArg_ParseTuple(args, "O!O!O!O!i:interpolate_bezier",
&vector_Type, &vec_k1,
&vector_Type, &vec_h1,
&vector_Type, &vec_h2,
&vector_Type, &vec_k2, &resolu)
) {
return NULL;
}
if(resolu <= 1) {
PyErr_SetString(PyExc_ValueError,
"resolution must be 2 or over");
return NULL;
}
if(BaseMath_ReadCallback(vec_k1) == -1 || BaseMath_ReadCallback(vec_h1) == -1 || BaseMath_ReadCallback(vec_k2) == -1 || BaseMath_ReadCallback(vec_h2) == -1)
return NULL;
dims= MAX4(vec_k1->size, vec_h1->size, vec_h2->size, vec_k2->size);
for(i=0; i < vec_k1->size; i++) k1[i]= vec_k1->vec[i];
for(i=0; i < vec_h1->size; i++) h1[i]= vec_h1->vec[i];
for(i=0; i < vec_k2->size; i++) k2[i]= vec_k2->vec[i];
for(i=0; i < vec_h2->size; i++) h2[i]= vec_h2->vec[i];
coord_array= MEM_callocN(dims * (resolu) * sizeof(float), "interpolate_bezier");
for(i=0; i<dims; i++) {
forward_diff_bezier(k1[i], h1[i], h2[i], k2[i], coord_array+i, resolu-1, sizeof(float)*dims);
}
list= PyList_New(resolu);
fp= coord_array;
for(i=0; i<resolu; i++, fp= fp+dims) {
PyList_SET_ITEM(list, i, newVectorObject(fp, dims, Py_NEW, NULL));
}
MEM_freeN(coord_array);
return list;
}
PyDoc_STRVAR(M_Geometry_tesselate_polygon_doc,
".. function:: tesselate_polygon(veclist_list)\n"
"\n"
" Takes a list of polylines (each point a vector) and returns the point indices for a polyline filled with triangles.\n"
"\n"
" :arg veclist_list: list of polylines\n"
" :rtype: list\n"
);
/* PolyFill function, uses Blenders scanfill to fill multiple poly lines */
static PyObject *M_Geometry_tesselate_polygon(PyObject *UNUSED(self), PyObject *polyLineSeq)
{
PyObject *tri_list; /*return this list of tri's */
PyObject *polyLine, *polyVec;
int i, len_polylines, len_polypoints, ls_error= 0;
/* display listbase */
ListBase dispbase={NULL, NULL};
DispList *dl;
float *fp; /*pointer to the array of malloced dl->verts to set the points from the vectors */
int index, *dl_face, totpoints=0;
if(!PySequence_Check(polyLineSeq)) {
PyErr_SetString(PyExc_TypeError,
"expected a sequence of poly lines");
return NULL;
}
len_polylines= PySequence_Size(polyLineSeq);
for(i= 0; i < len_polylines; ++i) {
polyLine= PySequence_GetItem(polyLineSeq, i);
if (!PySequence_Check(polyLine)) {
freedisplist(&dispbase);
Py_XDECREF(polyLine); /* may be null so use Py_XDECREF*/
PyErr_SetString(PyExc_TypeError,
"One or more of the polylines is not a sequence of mathutils.Vector's");
return NULL;
}
len_polypoints= PySequence_Size(polyLine);
if (len_polypoints>0) { /* dont bother adding edges as polylines */
#if 0
if (EXPP_check_sequence_consistency(polyLine, &vector_Type) != 1) {
freedisplist(&dispbase);
Py_DECREF(polyLine);
PyErr_SetString(PyExc_TypeError,
"A point in one of the polylines is not a mathutils.Vector type");
return NULL;
}
#endif
dl= MEM_callocN(sizeof(DispList), "poly disp");
BLI_addtail(&dispbase, dl);
dl->type= DL_INDEX3;
dl->nr= len_polypoints;
dl->type= DL_POLY;
dl->parts= 1; /* no faces, 1 edge loop */
dl->col= 0; /* no material */
dl->verts= fp= MEM_callocN(sizeof(float)*3*len_polypoints, "dl verts");
dl->index= MEM_callocN(sizeof(int)*3*len_polypoints, "dl index");
for(index= 0; index<len_polypoints; ++index, fp+=3) {
polyVec= PySequence_GetItem(polyLine, index);
if(VectorObject_Check(polyVec)) {
if(BaseMath_ReadCallback((VectorObject *)polyVec) == -1)
ls_error= 1;
fp[0]= ((VectorObject *)polyVec)->vec[0];
fp[1]= ((VectorObject *)polyVec)->vec[1];
if(((VectorObject *)polyVec)->size > 2)
fp[2]= ((VectorObject *)polyVec)->vec[2];
else
fp[2]= 0.0f; /* if its a 2d vector then set the z to be zero */
}
else {
ls_error= 1;
}
totpoints++;
Py_DECREF(polyVec);
}
}
Py_DECREF(polyLine);
}
if(ls_error) {
freedisplist(&dispbase); /* possible some dl was allocated */
PyErr_SetString(PyExc_TypeError,
"A point in one of the polylines "
"is not a mathutils.Vector type");
return NULL;
}
else if (totpoints) {
/* now make the list to return */
filldisplist(&dispbase, &dispbase, 0);
/* The faces are stored in a new DisplayList
thats added to the head of the listbase */
dl= dispbase.first;
tri_list= PyList_New(dl->parts);
if(!tri_list) {
freedisplist(&dispbase);
PyErr_SetString(PyExc_RuntimeError,
"failed to make a new list");
return NULL;
}
index= 0;
dl_face= dl->index;
while(index < dl->parts) {
PyList_SET_ITEM(tri_list, index, Py_BuildValue("iii", dl_face[0], dl_face[1], dl_face[2]));
dl_face+= 3;
index++;
}
freedisplist(&dispbase);
}
else {
/* no points, do this so scripts dont barf */
freedisplist(&dispbase); /* possible some dl was allocated */
tri_list= PyList_New(0);
}
return tri_list;
}
static int boxPack_FromPyObject(PyObject *value, boxPack **boxarray)
{
int len, i;
PyObject *list_item, *item_1, *item_2;
boxPack *box;
/* Error checking must already be done */
if(!PyList_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"can only back a list of [x, y, w, h]");
return -1;
}
len= PyList_Size(value);
(*boxarray)= MEM_mallocN(len*sizeof(boxPack), "boxPack box");
for(i= 0; i < len; i++) {
list_item= PyList_GET_ITEM(value, i);
if(!PyList_Check(list_item) || PyList_Size(list_item) < 4) {
MEM_freeN(*boxarray);
PyErr_SetString(PyExc_TypeError,
"can only pack a list of [x, y, w, h]");
return -1;
}
box= (*boxarray)+i;
item_1= PyList_GET_ITEM(list_item, 2);
item_2= PyList_GET_ITEM(list_item, 3);
box->w= (float)PyFloat_AsDouble(item_1);
box->h= (float)PyFloat_AsDouble(item_2);
box->index= i;
/* accounts for error case too and overwrites with own error */
if (box->w < 0.0f || box->h < 0.0f) {
MEM_freeN(*boxarray);
PyErr_SetString(PyExc_TypeError,
"error parsing width and height values from list: "
"[x, y, w, h], not numbers or below zero");
return -1;
}
/* verts will be added later */
}
return 0;
}
static void boxPack_ToPyObject(PyObject *value, boxPack **boxarray)
{
int len, i;
PyObject *list_item;
boxPack *box;
len= PyList_Size(value);
for(i= 0; i < len; i++) {
box= (*boxarray)+i;
list_item= PyList_GET_ITEM(value, box->index);
PyList_SET_ITEM(list_item, 0, PyFloat_FromDouble(box->x));
PyList_SET_ITEM(list_item, 1, PyFloat_FromDouble(box->y));
}
MEM_freeN(*boxarray);
}
PyDoc_STRVAR(M_Geometry_box_pack_2d_doc,
".. function:: box_pack_2d(boxes)\n"
"\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"
" :type boxes: list\n"
" :return: the width and height of the packed bounding box\n"
" :rtype: tuple, pair of floats\n"
);
static PyObject *M_Geometry_box_pack_2d(PyObject *UNUSED(self), PyObject *boxlist)
{
float tot_width= 0.0f, tot_height= 0.0f;
int len;
PyObject *ret;
if(!PyList_Check(boxlist)) {
PyErr_SetString(PyExc_TypeError,
"expected a list of boxes [[x, y, w, h], ... ]");
return NULL;
}
len= PyList_GET_SIZE(boxlist);
if (len) {
boxPack *boxarray= NULL;
if(boxPack_FromPyObject(boxlist, &boxarray) == -1) {
return NULL; /* exception set */
}
/* Non Python function */
boxPack2D(boxarray, len, &tot_width, &tot_height);
boxPack_ToPyObject(boxlist, &boxarray);
}
ret= PyTuple_New(2);
PyTuple_SET_ITEM(ret, 0, PyFloat_FromDouble(tot_width));
PyTuple_SET_ITEM(ret, 1, PyFloat_FromDouble(tot_width));
return ret;
}
#endif /* MATH_STANDALONE */
static PyMethodDef M_Geometry_methods[]= {
{"intersect_ray_tri", (PyCFunction) M_Geometry_intersect_ray_tri, METH_VARARGS, M_Geometry_intersect_ray_tri_doc},
{"intersect_point_line", (PyCFunction) M_Geometry_intersect_point_line, METH_VARARGS, M_Geometry_intersect_point_line_doc},
@@ -917,12 +1102,16 @@ static PyMethodDef M_Geometry_methods[]= {
{"intersect_line_line", (PyCFunction) M_Geometry_intersect_line_line, METH_VARARGS, M_Geometry_intersect_line_line_doc},
{"intersect_line_line_2d", (PyCFunction) M_Geometry_intersect_line_line_2d, METH_VARARGS, M_Geometry_intersect_line_line_2d_doc},
{"intersect_line_plane", (PyCFunction) M_Geometry_intersect_line_plane, METH_VARARGS, M_Geometry_intersect_line_plane_doc},
{"interpolate_bezier", (PyCFunction) M_Geometry_interpolate_bezier, METH_VARARGS, M_Geometry_interpolate_bezier_doc},
{"intersect_line_sphere", (PyCFunction) M_Geometry_intersect_line_sphere, METH_VARARGS, M_Geometry_intersect_line_sphere_doc},
{"intersect_line_sphere_2d", (PyCFunction) M_Geometry_intersect_line_sphere_2d, METH_VARARGS, M_Geometry_intersect_line_sphere_2d_doc},
{"area_tri", (PyCFunction) M_Geometry_area_tri, METH_VARARGS, M_Geometry_area_tri_doc},
{"normal", (PyCFunction) M_Geometry_normal, METH_VARARGS, M_Geometry_normal_doc},
{"barycentric_transform", (PyCFunction) M_Geometry_barycentric_transform, METH_VARARGS, M_Geometry_barycentric_transform_doc},
#ifndef MATH_STANDALONE
{"interpolate_bezier", (PyCFunction) M_Geometry_interpolate_bezier, METH_VARARGS, M_Geometry_interpolate_bezier_doc},
{"tesselate_polygon", (PyCFunction) M_Geometry_tesselate_polygon, METH_O, M_Geometry_tesselate_polygon_doc},
{"box_pack_2d", (PyCFunction) M_Geometry_box_pack_2d, METH_O, M_Geometry_box_pack_2d_doc},
{"barycentric_transform", (PyCFunction) M_Geometry_barycentric_transform, METH_VARARGS, M_Geometry_barycentric_transform_doc},
#endif
{NULL, NULL, 0, NULL}
};
@@ -939,7 +1128,7 @@ static struct PyModuleDef M_Geometry_module_def= {
};
/*----------------------------MODULE INIT-------------------------*/
PyMODINIT_FUNC BPyInit_mathutils_geometry(void)
PyMODINIT_FUNC PyInit_mathutils_geometry(void)
{
PyObject *submodule= PyModule_Create(&M_Geometry_module_def);
return submodule;

2
source/blender/python/generic/mathutils_geometry.h → source/blender/python/mathutils/mathutils_geometry.h
View File

@@ -38,6 +38,6 @@
#include "mathutils.h"
PyMODINIT_FUNC BPyInit_mathutils_geometry(void);
PyMODINIT_FUNC PyInit_mathutils_geometry(void);
#endif /* MATHUTILS_GEOMETRY_H */