archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
009e5d00cb2a76694d42f5e47a3ac3cb6afa595e
blender-archive/source/blender/python/api2_2x/Node.c
Willian Padovani Germano dae503187c == PyNodes == 
Ongoing updates to the Blender.Node Python API:

- Changed Blender.Node.node to Blender.Node.Scripted to be more specific and conform to bpython API.
- Added a Blender.Node.Socket type to be used to define node sockets in a PyNode script. Also, socket type is inferred from the value(s) passed in, instead of also being defined by the script author.
- Added attr access to input and output sockets in the __call__ method. Ex: an input socket called 'color' can be accessed as self.input.color now.

These changes break existing pynode scripts, which shouldn't be a problem yet, of course, since we're still finishing this feature for 2.46. The wiki page and sample .blends have already been updated:

http://wiki.blender.org/index.php/BlenderDev/PyNodes
http://wiki.blender.org/index.php/BlenderDev/PyNodes/API
2008-03-16 17:24:29 +00:00

1622 lines
51 KiB
C
Raw Blame History

/*
* $Id$
*
* ***** BEGIN GPL/BL DUAL 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. The Blender
* Foundation also sells licenses for use in proprietary software under
* the Blender License. See http://www.blender.org/BL/ for information
* about this.
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2006, Blender Foundation
* All rights reserved.
*
* Original code is this file
*
* Contributor(s): Nathan Letwory
*
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
#include "Node.h"
#include "BKE_global.h"
#include "BKE_main.h"
#include "BKE_node.h"
#include "BKE_utildefines.h"
#include "DNA_material_types.h"
#include "MEM_guardedalloc.h"
#include "BLI_blenlib.h"
#include "gen_utils.h"
#include "vector.h"
static PyObject *Node_repr( BPy_Node * self );
static int Node_compare(BPy_Node *a, BPy_Node *b);
static PyObject *ShadeInput_repr( BPy_ShadeInput * self );
static int ShadeInput_compare(BPy_ShadeInput *a, BPy_ShadeInput *b);
static BPy_ShadeInput *ShadeInput_CreatePyObject(ShadeInput *shi);
/* node socket type */
static PyObject *NodeSocket_getName(BPy_NodeSocket *self, void *unused)
{
return PyString_FromString(self->name);
}
static int NodeSocket_setName(BPy_NodeSocket *self, PyObject *value, void *unused)
{
char *name = NULL;
if (!PyString_Check(value))
return EXPP_ReturnIntError( PyExc_TypeError,
"expected a string" );
name = PyString_AsString(value);
if (!name)
return EXPP_ReturnIntError(PyExc_RuntimeError,
"couldn't convert value to string!");
BLI_strncpy(self->name, name, NODE_MAXSTR);
return 0;
}
static PyObject *NodeSocket_getVal(BPy_NodeSocket *self, void *unused)
{
PyObject *pyret = NULL;
if (self->type == SOCK_VALUE) {
pyret = PyFloat_FromDouble(self->val[0]);
}
else { /* VECTOR or RGBA */
pyret = newVectorObject(self->val, self->type, Py_NEW);
if (!pyret)
return EXPP_ReturnPyObjError(PyExc_RuntimeError,
"couldn't create vector object!");
}
return pyret;
}
static int NodeSocket_setVal(BPy_NodeSocket *self, PyObject *value, void *unused)
{
int error = 0;
if (PySequence_Check(value)) {
PyObject *item, *fpyval;
int i, len;
len = PySequence_Size(value);
if (len == 3 || len == 4) {
for (i = 0; i < len; i++) {
item = PySequence_GetItem(value, i);
fpyval = PyNumber_Float(item);
if (!fpyval) {
Py_DECREF(item);
error = 1;
break;
}
self->val[i] = (float)PyFloat_AsDouble(fpyval);
Py_DECREF(item);
Py_DECREF(fpyval);
}
if (len == 3)
self->type = SOCK_VECTOR;
else /* len == 4 */
self->type = SOCK_RGBA;
}
else error = 1;
}
else if (VectorObject_Check(value)) {
VectorObject *vecOb = (VectorObject *)value;
short vlen = vecOb->size;
if (vlen == 3 || vlen == 4) {
VECCOPY(self->val, vecOb->vec); /* copies 3 values */
if (vlen == 3)
self->type = SOCK_VECTOR;
else {
self->val[3] = vecOb->vec[3];
self->type = SOCK_RGBA;
}
}
else error = 1;
}
else if (PyNumber_Check(value)) {
self->val[0] = (float)PyFloat_AsDouble(value);
self->type = SOCK_VALUE;
}
else error = 1;
if (error)
return EXPP_ReturnIntError( PyExc_TypeError,
"expected a float or a sequence (or vector) of 3 or 4 floats" );
return 0;
}
static PyObject *NodeSocket_getMin(BPy_NodeSocket *self, void *unused)
{
return PyFloat_FromDouble(self->min);
}
static int NodeSocket_setMin(BPy_NodeSocket *self, PyObject *value, void *unused)
{
PyObject *pyval = PyNumber_Float(value);
if (!pyval)
return EXPP_ReturnIntError( PyExc_TypeError,
"expected a float number" );
self->min = (float)PyFloat_AsDouble(pyval);
Py_DECREF(pyval);
return 0;
}
static PyObject *NodeSocket_getMax(BPy_NodeSocket *self, void *unused)
{
return PyFloat_FromDouble(self->max);
}
static int NodeSocket_setMax(BPy_NodeSocket *self, PyObject *value, void *unused)
{
PyObject *pyval = PyNumber_Float(value);
if (!pyval)
return EXPP_ReturnIntError( PyExc_TypeError,
"expected a float number" );
self->max = (float)PyFloat_AsDouble(pyval);
Py_DECREF(pyval);
return 0;
}
static PyGetSetDef NodeSocket_getseters[] = {
{"name", (getter)NodeSocket_getName, (setter)NodeSocket_setName,
"This socket's name", NULL},
{"val", (getter)NodeSocket_getVal, (setter)NodeSocket_setVal,
"This socket's data value(s)", NULL},
{"min", (getter)NodeSocket_getMin, (setter)NodeSocket_setMin,
"This socket's min possible value (lower range limit)", NULL},
{"max", (getter)NodeSocket_getMax, (setter)NodeSocket_setMax,
"This socket's max possible value (upper range limit)", NULL},
{NULL,NULL,NULL,NULL,NULL} /* Sentinel */
};
static void NodeSocket_dealloc(BPy_NodeSocket *self)
{
self->ob_type->tp_free((PyObject *)self);
}
static PyObject *NodeSocket_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
PyObject *pysocket = type->tp_alloc(type, 0);
if (!pysocket)
return EXPP_ReturnPyObjError(PyExc_RuntimeError, "couldn't create socket type!");
return pysocket;
}
static int NodeSocket_init(BPy_NodeSocket *self, PyObject *args, PyObject *kwargs)
{
char *name = NULL;
float min = 0.0f, max = 1.0f;
PyObject *val = NULL;
static char *kwlist[] = {"name", "val", "min", "max", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|Off", kwlist, &name, &val, &min, &max)){
return EXPP_ReturnIntError(PyExc_AttributeError, "expected a string and optionally:\n1) a float or a sequence (or vector) of 3 or 4 floats and\n2) two floats");
}
BLI_strncpy(self->name, name, NODE_MAXSTR);
self->min = min;
self->max = max;
if (val)
return NodeSocket_setVal(self, val, NULL);
/* else */
self->type = SOCK_VALUE;
self->val[0] = 0.0f;
return 0;
}
static PyObject *NodeSocket_copy(BPy_NodeSocket *self)
{
BPy_NodeSocket *copied;
copied = (BPy_NodeSocket*)NodeSocket_new(&NodeSocket_Type, NULL, NULL);
if (!copied) return NULL; /* error already set in NodeSocket_new */
BLI_strncpy(copied->name, self->name, NODE_MAXSTR);
copied->min = self->min;
copied->max = self->max;
copied->type = self->type;
memcpy(copied->val, self->val, 4*sizeof(float));
return (PyObject *)copied;
}
static PyMethodDef BPy_NodeSocket_methods[] = {
{"__copy__", ( PyCFunction ) NodeSocket_copy, METH_NOARGS,
"() - Makes a copy of this node socket."},
{"copy", ( PyCFunction ) NodeSocket_copy, METH_NOARGS,
"() - Makes a copy of this node socket."},
{NULL, NULL, 0, NULL}
};
PyTypeObject NodeSocket_Type = {
PyObject_HEAD_INIT( NULL ) /* required py macro */
0, /* ob_size */
/* For printing, in format "<module>.<name>" */
"Blender.Node.Socket", /* char *tp_name; */
sizeof( BPy_NodeSocket ), /* int tp_basicsize; */
0, /* tp_itemsize; For allocation */
/* Methods to implement standard operations */
(destructor)NodeSocket_dealloc,/* destructor tp_dealloc; */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* cmpfunc tp_compare; */
NULL, /* reprfunc tp_repr; */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* 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/input buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* 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 */
0, //( getiterfunc) MVertSeq_getIter, /* getiterfunc tp_iter; */
0, //( iternextfunc ) MVertSeq_nextIter, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
BPy_NodeSocket_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NodeSocket_getseters, /* struct PyGetSetDef *tp_getset; */
NULL, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)NodeSocket_init, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NodeSocket_new, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
/**
* Take the descriptions from tuple and create sockets for those in socks
* socks is a socketstack from a bNodeTypeInfo
*/
static int pysockets_to_blendersockets(PyObject *tuple, bNodeSocketType **socks, int stage, int limit) {
int len = 0, a = 0, pos = 0, retval = 0;
short stype;
BPy_NodeSocket *pysock;
bNodeSocketType *nsocks = NULL;
if (BTST2(stage, NODE_DYNAMIC_READY, NODE_DYNAMIC_ADDEXIST))
return 0; /* already has sockets */
len = PyTuple_Size(tuple);
nsocks = MEM_callocN(sizeof(bNodeSocketType)*(len+1), "bNodeSocketType in Node.c");
for (pos = 0, a = 0; pos< len; pos++, a++) {
pysock = (BPy_NodeSocket *)PyTuple_GetItem(tuple, pos);/*borrowed*/
if (!BPy_NodeSocket_Check(pysock)) {
PyErr_SetString(PyExc_AttributeError, "expected a sequence of node sockets");
retval = -1;
break;
}
stype = pysock->type;
nsocks[a].type = stype;
nsocks[a].limit = limit;
nsocks[a].name = BLI_strdupn(pysock->name, NODE_MAXSTR);
nsocks[a].min = pysock->min;
nsocks[a].max = pysock->max;
if (stype > SOCK_VALUE) {
float *vec = pysock->val;
nsocks[a].val1 = vec[0];
nsocks[a].val2 = vec[1];
nsocks[a].val3 = vec[2];
if (stype == SOCK_RGBA)
nsocks[a].val4 = vec[3];
}
else /* SOCK_VALUE */
nsocks[a].val1 = pysock->val[0];
}
nsocks[a].type = -1;
*socks = nsocks;
return retval;
}
static void NodeSocketLists_dealloc(BPy_NodeSocketLists *self)
{
Py_DECREF(self->input);
Py_DECREF(self->output);
self->ob_type->tp_free((PyObject *)self);
}
static PyObject *Map_socketdef_getter(BPy_NodeSocketLists *self, void *closure)
{
PyObject *sockets = NULL;
switch ((int)closure) {
case 'I': /* inputs */
Py_INCREF(self->input);
sockets = self->input;
break;
case 'O': /* outputs */
Py_INCREF(self->output);
sockets = self->output;
break;
default:
fprintf(stderr, "DEBUG pynodes: wrong option in Map_socketdef_getter\n");
Py_INCREF(Py_None);
sockets = Py_None;
break;
}
return sockets;
}
static int Map_socketdef(BPy_NodeSocketLists *self, PyObject *args, void *closure)
{
bNode *node = NULL;
PyObject *tuple = NULL;
node = self->node;
if(!node) {
fprintf(stderr,"DEBUG pynodes: No bNode in BPy_Node (Map_socketdef)\n");
return 0;
}
if(BTST2(node->custom1, NODE_DYNAMIC_READY, NODE_DYNAMIC_ADDEXIST))
return 0;
switch((int)closure) {
case 'I':
if (args) {
if(PySequence_Check(args)) {
tuple = PySequence_Tuple(args);
pysockets_to_blendersockets(tuple,
&(node->typeinfo->inputs), node->custom1, 1);
Py_DECREF(self->input);
self->input = tuple;
} else {
return(EXPP_ReturnIntError( PyExc_AttributeError, "INPUT must be a List of Lists or Tuples"));
}
}
break;
case 'O':
if (args) {
if(PyList_Check(args)) {
tuple = PySequence_Tuple(args);
pysockets_to_blendersockets(tuple,
&(node->typeinfo->outputs), node->custom1, 0);
Py_DECREF(self->output);
self->output = tuple;
} else {
return(EXPP_ReturnIntError( PyExc_AttributeError, "OUTPUT must be a List of Lists or Tuples"));
}
}
break;
default:
fprintf(stderr,"DEBUG pynodes: got no list in Map_socketdef\n");
break;
}
return 0;
}
static PyGetSetDef NodeSocketLists_getseters[] = {
{"input", (getter)Map_socketdef_getter, (setter)Map_socketdef,
"Set this node's input sockets (list of lists or tuples)",
(void *)'I'},
{"i" /*alias*/, (getter)Map_socketdef_getter, (setter)Map_socketdef,
"Set this node's input sockets (list of lists or tuples)",
(void *)'I'},
{"output", (getter)Map_socketdef_getter, (setter)Map_socketdef,
"Set this node's output sockets (list of lists or tuples)",
(void *)'O'},
{"o" /*alias*/, (getter)Map_socketdef_getter, (setter)Map_socketdef,
"Set this node's output sockets (list of lists or tuples)",
(void *)'O'},
{NULL,NULL,NULL,NULL,NULL} /* Sentinel */
};
PyTypeObject NodeSocketLists_Type = {
PyObject_HEAD_INIT( NULL ) /* required py macro */
0, /* ob_size */
/* For printing, in format "<module>.<name>" */
"Blender.Node.SocketLists", /* char *tp_name; */
sizeof( BPy_NodeSocketLists ), /* int tp_basicsize; */
0, /* tp_itemsize; For allocation */
/* Methods to implement standard operations */
(destructor)NodeSocketLists_dealloc,/* destructor tp_dealloc; */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* cmpfunc tp_compare; */
NULL, /* reprfunc tp_repr; */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* 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/input 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 */
0, //( getiterfunc) MVertSeq_getIter, /* getiterfunc tp_iter; */
0, //( iternextfunc ) MVertSeq_nextIter, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
0, //BPy_MVertSeq_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NodeSocketLists_getseters, /* struct PyGetSetDef *tp_getset; */
NULL, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
NULL, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
BPy_NodeSocketLists *Node_CreateSocketLists(bNode *node) {
BPy_NodeSocketLists *socklists = PyObject_NEW(BPy_NodeSocketLists, &NodeSocketLists_Type);
socklists->node = node;
socklists->input = PyList_New(0);
socklists->output = PyList_New(0);
return socklists;
}
/***************************************/
static int Sockinmap_len ( BPy_SockMap * self) {
bNode *node = self->node;
bNodeType *tinfo;
int a = 0;
if (!node) return 0;
tinfo = node->typeinfo;
if (BNTST(node->custom1, NODE_DYNAMIC_READY)) return 0;
if (tinfo && tinfo->inputs) {
while(self->node->typeinfo->inputs[a].type!=-1)
a++;
}
return a;
}
static int sockinmap_has_key( BPy_SockMap *self, char *strkey) {
bNode *node = self->node;
bNodeType *tinfo;
int a = 0;
if (!node || !strkey) return -1;
tinfo = node->typeinfo;
if(tinfo && tinfo->inputs){
while(self->node->typeinfo->inputs[a].type!=-1) {
if(BLI_strcaseeq(self->node->typeinfo->inputs[a].name, strkey)) {
return a;
}
a++;
}
}
return -1;
}
PyObject *Sockinmap_subscript(BPy_SockMap *self, PyObject *pyidx) {
int idx;
if (!self->node)
return EXPP_ReturnPyObjError(PyExc_RuntimeError, "no access to Blender node data!");
if (PyString_Check(pyidx)) {
idx = sockinmap_has_key(self, PyString_AsString(pyidx));
}
else if(PyInt_Check(pyidx)) {
int len = Sockinmap_len(self);
idx = (int)PyInt_AsLong(pyidx);
if (idx < 0 || idx >= len)
return EXPP_ReturnPyObjError(PyExc_IndexError, "index out of range");
}
else if (PySlice_Check(pyidx)) {
return EXPP_ReturnPyObjError(PyExc_ValueError, "slices not implemented");
} else {
return EXPP_ReturnPyObjError(PyExc_IndexError, "index must be an int or a string");
}
if(idx<0) { /* we're not as nice as Python */
return EXPP_ReturnPyObjError(PyExc_IndexError, "invalid socket index");
}
switch(self->node->typeinfo->inputs[idx].type) {
case SOCK_VALUE:
return Py_BuildValue("f", self->stack[idx]->vec[0]);
break;
case SOCK_VECTOR:
return Py_BuildValue("(fff)", self->stack[idx]->vec[0], self->stack[idx]->vec[1], self->stack[idx]->vec[2]);
break;
case SOCK_RGBA:
/* otherwise RGBA tuple */
return Py_BuildValue("(ffff)", self->stack[idx]->vec[0], self->stack[idx]->vec[1], self->stack[idx]->vec[2], self->stack[idx]->vec[3]);
break;
default:
break;
}
Py_RETURN_NONE;
}
static PyObject *Sockinmap_getAttr(BPy_SockMap *self, char *attr)
{
PyObject *pyob = NULL;
int idx;
idx = sockinmap_has_key(self, attr);
if (idx < 0)
return EXPP_ReturnPyObjError(PyExc_AttributeError, "unknown input socket name");
switch(self->node->typeinfo->inputs[idx].type) {
case SOCK_VALUE:
pyob = Py_BuildValue("f", self->stack[idx]->vec[0]);
break;
case SOCK_VECTOR:
pyob = Py_BuildValue("(fff)", self->stack[idx]->vec[0], self->stack[idx]->vec[1], self->stack[idx]->vec[2]);
break;
case SOCK_RGBA:
pyob = Py_BuildValue("(ffff)", self->stack[idx]->vec[0], self->stack[idx]->vec[1], self->stack[idx]->vec[2], self->stack[idx]->vec[3]);
break;
default:
break;
}
return pyob;
}
/* read only */
static PyMappingMethods Sockinmap_as_mapping = {
( inquiry ) Sockinmap_len, /* mp_length */
( binaryfunc ) Sockinmap_subscript, /* mp_subscript */
( objobjargproc ) 0 /* mp_ass_subscript */
};
PyTypeObject SockInMap_Type = {
PyObject_HEAD_INIT( NULL ) /* required py macro */
0, /* ob_size */
/* For printing, in format "<module>.<name>" */
"Blender.Node.InputSockets", /* char *tp_name; */
sizeof( BPy_SockMap ), /* int tp_basicsize; */
0, /* tp_itemsize; For allocation */
/* Methods to implement standard operations */
NULL,/* destructor tp_dealloc; */
NULL, /* printfunc tp_print; */
(getattrfunc) Sockinmap_getAttr,/* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* cmpfunc tp_compare; */
NULL, /* reprfunc tp_repr; */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
&Sockinmap_as_mapping, /* 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 */
0, //( getiterfunc) MVertSeq_getIter, /* getiterfunc tp_iter; */
0, //( iternextfunc ) MVertSeq_nextIter, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
0, //BPy_MVertSeq_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
NULL, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
NULL, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
static int Sockoutmap_len ( BPy_SockMap * self) {
bNode *node = self->node;
bNodeType *tinfo;
int a = 0;
if (!node) return 0;
tinfo = node->typeinfo;
if (tinfo && tinfo->outputs) {
while(self->node->typeinfo->outputs[a].type!=-1)
a++;
}
return a;
}
static int sockoutmap_has_key(BPy_SockMap *self, char *strkey) {
bNode *node = self->node;
bNodeType *tinfo;
int a = 0;
if (!node) return -1;
tinfo = node->typeinfo;
if(tinfo && tinfo->outputs){
while(self->node->typeinfo->outputs[a].type!=-1) {
if(BLI_strcaseeq(self->node->typeinfo->outputs[a].name, strkey)) {
return a;
}
a++;
}
}
return -1;
}
static int Sockoutmap_assign_subscript(BPy_SockMap *self, PyObject *pyidx, PyObject *value) {
int i, idx, len, type, wanted_len = 0;
PyObject *val;
PyObject *items[4];
if (!self->node)
return EXPP_ReturnIntError(PyExc_RuntimeError, "no access to Blender node data!");
if (PyInt_Check(pyidx)) {
idx = (int)PyInt_AsLong(pyidx);
if (idx < 0 || idx >= Sockinmap_len(self))
return EXPP_ReturnIntError(PyExc_IndexError, "index out of range");
}
else if (PyString_Check(pyidx)) {
idx = sockoutmap_has_key(self, PyString_AsString(pyidx));
}
else if (PySlice_Check(pyidx)) {
return EXPP_ReturnIntError(PyExc_ValueError, "slices not yet implemented");
} else {
return EXPP_ReturnIntError(PyExc_IndexError, "index must be a positive int or a string");
}
if (idx < 0)
return EXPP_ReturnIntError(PyExc_IndexError, "index must be a positive int or a string");
type = self->node->typeinfo->outputs[idx].type;
if (type == SOCK_VALUE) {
val = PyNumber_Float(value);
if (!val)
return EXPP_ReturnIntError(PyExc_AttributeError, "expected a float value");
self->stack[idx]->vec[0] = (float)PyFloat_AsDouble(val);
Py_DECREF(val);
}
else {
val = PySequence_Fast(value, "expected a numeric tuple or list");
if (!val) return -1;
len = PySequence_Fast_GET_SIZE(val);
if (type == SOCK_VECTOR) {
wanted_len = 3;
} else { /* SOCK_RGBA */
wanted_len = 4;
}
if (len != wanted_len) {
Py_DECREF(val);
PyErr_SetString(PyExc_AttributeError, "wrong number of items in list or tuple");
fprintf(stderr, "\nExpected %d numeric values, got %d.", wanted_len, len);
return -1;
}
for (i = 0; i < len; i++) {
items[i] = PySequence_Fast_GET_ITEM(val, i); /* borrowed */
if (!PyNumber_Check(items[i])) {
Py_DECREF(val);
return EXPP_ReturnIntError(PyExc_AttributeError, "expected a *numeric* tuple or list");
}
}
self->stack[idx]->vec[0] = (float)PyFloat_AsDouble(items[0]);
self->stack[idx]->vec[1] = (float)PyFloat_AsDouble(items[1]);
self->stack[idx]->vec[2] = (float)PyFloat_AsDouble(items[2]);
if (type == SOCK_RGBA)
self->stack[idx]->vec[3] = (float)PyFloat_AsDouble(items[3]);
Py_DECREF(val);
}
return 0;
}
static int sockoutmap_set_attr(bNodeStack **stack, short type, short idx, PyObject *value)
{
PyObject *val;
PyObject *items[4];
int i;
short len, wanted_len;
if (type == SOCK_VALUE) {
val = PyNumber_Float(value);
if (!val)
return EXPP_ReturnIntError(PyExc_AttributeError, "expected a float value");
stack[idx]->vec[0] = (float)PyFloat_AsDouble(val);
Py_DECREF(val);
}
else {
val = PySequence_Fast(value, "expected a numeric tuple or list");
if (!val) return -1;
len = PySequence_Fast_GET_SIZE(val);
if (type == SOCK_VECTOR) {
wanted_len = 3;
} else { /* SOCK_RGBA */
wanted_len = 4;
}
if (len != wanted_len) {
Py_DECREF(val);
PyErr_SetString(PyExc_AttributeError, "wrong number of items in list or tuple");
fprintf(stderr, "\nExpected %d numeric values, got %d.", wanted_len, len);
return -1;
}
for (i = 0; i < len; i++) {
items[i] = PySequence_Fast_GET_ITEM(val, i); /* borrowed */
if (!PyNumber_Check(items[i])) {
Py_DECREF(val);
return EXPP_ReturnIntError(PyExc_AttributeError, "expected a *numeric* tuple or list");
}
}
stack[idx]->vec[0] = (float)PyFloat_AsDouble(items[0]);
stack[idx]->vec[1] = (float)PyFloat_AsDouble(items[1]);
stack[idx]->vec[2] = (float)PyFloat_AsDouble(items[2]);
if (type == SOCK_RGBA)
stack[idx]->vec[3] = (float)PyFloat_AsDouble(items[3]);
Py_DECREF(val);
}
return 0;
}
static int Sockoutmap_setAttr(BPy_SockMap *self, char *name, PyObject *value) {
short idx, type;
if (!self->node)
return EXPP_ReturnIntError(PyExc_RuntimeError, "no access to Blender node data!");
idx = sockoutmap_has_key(self, name);
if (idx < 0)
return EXPP_ReturnIntError(PyExc_AttributeError, "unknown output socket name");
type = self->node->typeinfo->outputs[idx].type;
return sockoutmap_set_attr(self->stack, type, idx, value);
}
/* write only */
static PyMappingMethods Sockoutmap_as_mapping = {
( inquiry ) Sockoutmap_len, /* mp_length */
( binaryfunc ) 0, /* mp_subscript */
( objobjargproc ) Sockoutmap_assign_subscript /* mp_ass_subscript */
};
PyTypeObject SockOutMap_Type = {
PyObject_HEAD_INIT( NULL ) /* required py macro */
0, /* ob_size */
/* For printing, in format "<module>.<name>" */
"Blender.Node.OutputSockets", /* char *tp_name; */
sizeof( BPy_SockMap ), /* int tp_basicsize; */
0, /* tp_itemsize; For allocation */
/* Methods to implement standard operations */
NULL,/* destructor tp_dealloc; */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
(setattrfunc) Sockoutmap_setAttr,/* setattrfunc tp_setattr; */
NULL, /* cmpfunc tp_compare; */
NULL, /* reprfunc tp_repr; */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
&Sockoutmap_as_mapping, /* 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 */
0, //( getiterfunc) MVertSeq_getIter, /* getiterfunc tp_iter; */
0, //( iternextfunc ) MVertSeq_nextIter, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
0, //BPy_MVertSeq_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
NULL, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
NULL, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
static BPy_SockMap *Node_CreateInputMap(bNode *node, bNodeStack **stack) {
BPy_SockMap *map = PyObject_NEW(BPy_SockMap, &SockInMap_Type);
map->node = node;
map->stack = stack;
return map;
}
static PyObject *Node_GetInputMap(BPy_Node *self) {
BPy_SockMap *inmap = Node_CreateInputMap(self->node, self->in);
return (PyObject *)(inmap);
}
#define SURFACEVIEWVECTOR 0
#define VIEWNORMAL 1
#define SURFACENORMAL 2
#define GLOBALTEXTURE 3
#define TEXTURE 4
#define PIXEL 5
#define COLOR 6
#define SPECULAR_COLOR 7
#define MIRROR_COLOR 8
#define AMBIENT_COLOR 9
#define AMBIENT 10
#define EMIT 11
#define DISPLACE 12
#define STRAND 13
#define STRESS 14
#define TANGENT 15
#define SURFACE_D 30
#define TEXTURE_D 31
#define GLOBALTEXTURE_D 32
#define REFLECTION_D 33
#define NORMAL_D 34
#define STICKY_D 35
#define REFRACT_D 36
#define STRAND_D 37
static PyObject *ShadeInput_getAttribute(BPy_ShadeInput *self, void *type) {
PyObject *obj = NULL;
if(self->shi) {
switch((int)type) {
case SURFACEVIEWVECTOR:
obj = Py_BuildValue("(fff)", self->shi->view[0], self->shi->view[1], self->shi->view[2]);
break;
case VIEWNORMAL:
obj = Py_BuildValue("(fff)", self->shi->vn[0], self->shi->vn[1], self->shi->vn[2]);
break;
case SURFACENORMAL:
obj = Py_BuildValue("(fff)", self->shi->facenor[0], self->shi->facenor[1], self->shi->facenor[2]);
break;
case GLOBALTEXTURE:
obj = Py_BuildValue("(fff)", self->shi->gl[0], self->shi->gl[1], self->shi->gl[2]);
break;
case TEXTURE:
obj = Py_BuildValue("(fff)", self->shi->lo[0], self->shi->lo[1], self->shi->lo[2]);
break;
case PIXEL:
obj = Py_BuildValue("(ii)", self->shi->xs, self->shi->ys);
break;
case COLOR:
obj = Py_BuildValue("(fff)", self->shi->r, self->shi->g, self->shi->b);
break;
case SPECULAR_COLOR:
obj = Py_BuildValue("(fff)", self->shi->specr, self->shi->specg, self->shi->specb);
break;
case MIRROR_COLOR:
obj = Py_BuildValue("(fff)", self->shi->mirr, self->shi->mirg, self->shi->mirb);
break;
case AMBIENT_COLOR:
obj = Py_BuildValue("(fff)", self->shi->ambr, self->shi->ambg, self->shi->ambb);
break;
case AMBIENT:
obj = PyFloat_FromDouble((double)(self->shi->amb));
break;
case EMIT:
obj = PyFloat_FromDouble((double)(self->shi->emit));
break;
case DISPLACE:
obj = Py_BuildValue("(fff)", self->shi->displace[0], self->shi->displace[1], self->shi->displace[2]);
break;
case STRAND:
obj = PyFloat_FromDouble((double)(self->shi->strandco));
break;
case STRESS:
obj = PyFloat_FromDouble((double)(self->shi->stress));
break;
case TANGENT:
obj = Py_BuildValue("(fff)", self->shi->tang[0], self->shi->tang[1], self->shi->tang[2]);
break;
case SURFACE_D:
obj = Py_BuildValue("(fff)(fff)", self->shi->dxco[0], self->shi->dxco[1], self->shi->dxco[2], self->shi->dyco[0], self->shi->dyco[1], self->shi->dyco[2]);
break;
case TEXTURE_D:
obj = Py_BuildValue("(fff)(fff)", self->shi->dxlo[0], self->shi->dxlo[1], self->shi->dxlo[2], self->shi->dylo[0], self->shi->dylo[1], self->shi->dylo[2]);
break;
case GLOBALTEXTURE_D:
obj = Py_BuildValue("(fff)(fff)", self->shi->dxgl[0], self->shi->dxgl[1], self->shi->dxgl[2], self->shi->dygl[0], self->shi->dygl[1], self->shi->dygl[2]);
break;
case REFLECTION_D:
obj = Py_BuildValue("(fff)(fff)", self->shi->dxref[0], self->shi->dxref[1], self->shi->dxref[2], self->shi->dyref[0], self->shi->dyref[1], self->shi->dyref[2]);
break;
case NORMAL_D:
obj = Py_BuildValue("(fff)(fff)", self->shi->dxno[0], self->shi->dxno[1], self->shi->dxno[2], self->shi->dyno[0], self->shi->dyno[1], self->shi->dyno[2]);
break;
case STICKY_D:
obj = Py_BuildValue("(fff)(fff)", self->shi->dxsticky[0], self->shi->dxsticky[1], self->shi->dxsticky[2], self->shi->dysticky[0], self->shi->dysticky[1], self->shi->dysticky[2]);
break;
case REFRACT_D:
obj = Py_BuildValue("(fff)(fff)", self->shi->dxrefract[0], self->shi->dxrefract[1], self->shi->dxrefract[2], self->shi->dyrefract[0], self->shi->dyrefract[1], self->shi->dyrefract[2]);
break;
case STRAND_D:
obj = Py_BuildValue("(ff)", self->shi->dxstrand, self->shi->dystrand);
break;
default:
break;
}
}
if(!obj) {
Py_RETURN_NONE;
}
return obj;
}
static BPy_SockMap *Node_CreateOutputMap(bNode *node, bNodeStack **stack) {
BPy_SockMap *map = PyObject_NEW(BPy_SockMap, &SockOutMap_Type);
map->node = node;
map->stack = stack;
return map;
}
static PyObject *Node_GetOutputMap(BPy_Node *self) {
BPy_SockMap *outmap = Node_CreateOutputMap(self->node, self->out);
return (PyObject *)outmap;
}
static PyObject *Node_GetShi(BPy_Node *self) {
BPy_ShadeInput *shi = ShadeInput_CreatePyObject(self->shi);
return (PyObject *)shi;
}
static PyObject *node_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
PyObject *self;
self = type->tp_alloc(type, 1);
return self;
}
static int node_init(BPy_Node *self, PyObject *args, PyObject *kwds)
{
return 0;
}
static PyGetSetDef BPy_Node_getseters[] = {
{"input",
(getter)Node_GetInputMap, (setter)NULL,
"Get the input sockets mapping (dictionary)",
NULL},
{"i", /* alias */
(getter)Node_GetInputMap, (setter)NULL,
"Get the input sockets mapping (dictionary)",
NULL},
{"output",
(getter)Node_GetOutputMap, (setter)NULL,
"Get the output sockets mapping (dictionary)",
NULL},
{"o", /* alias */
(getter)Node_GetOutputMap, (setter)NULL,
"Get the output sockets mapping (dictionary)",
NULL},
{"shi",
(getter)Node_GetShi, (setter)NULL,
"Get the Shade Input data (ShadeInput)",
NULL},
{"s", /* alias */
(getter)Node_GetShi, (setter)NULL,
"Get the Shade Input data (ShadeInput)",
NULL},
{NULL,NULL,NULL,NULL,NULL} /* Sentinel */
};
static PyGetSetDef BPy_ShadeInput_getseters[] = {
{"texture",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the current texture coordinate (tuple)",
(void*)TEXTURE},
{"textureGlobal",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the current global texture coordinate (tuple)",
(void*)GLOBALTEXTURE},
{"surfaceNormal",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the current surface normal (tuple)",
(void*)SURFACENORMAL},
{"viewNormal",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the current view normal (tuple)",
(void*)VIEWNORMAL},
{"surfaceViewVector",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the vector pointing to the viewpoint from the point being shaded (tuple)",
(void*)SURFACEVIEWVECTOR},
{"pixel",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the x,y-coordinate for the pixel rendered (tuple)",
(void*)PIXEL},
{"color",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the color for the point being shaded (tuple)",
(void*)COLOR},
{"specularColor",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the specular color for the point being shaded (tuple)",
(void*)SPECULAR_COLOR},
{"mirrorColor",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the mirror color for the point being shaded (tuple)",
(void*)MIRROR_COLOR},
{"ambientColor",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the ambient color for the point being shaded (tuple)",
(void*)AMBIENT_COLOR},
{"ambient",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the ambient factor for the point being shaded (float)",
(void*)AMBIENT},
{"emit",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the emit factor for the point being shaded (float)",
(void*)EMIT},
{"displace",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the displace vector for the point being shaded (tuple)",
(void*)DISPLACE},
{"strand",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the strand factor(float)",
(void*)STRAND},
{"stress",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the stress factor(float)",
(void*)STRESS},
{"tangent",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the tangent vector (tuple)",
(void*)TANGENT},
{"surfaceD",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the surface d (tuple of tuples)",
(void*)SURFACE_D},
{"textureD",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the texture d (tuple of tuples)",
(void*)TEXTURE_D},
{"textureGlobalD",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the global texture d (tuple of tuples)",
(void*)GLOBALTEXTURE_D},
{"reflectionD",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the reflection d (tuple of tuples)",
(void*)REFLECTION_D},
{"normalD",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the normal d (tuple of tuples)",
(void*)NORMAL_D},
{"stickyD",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the sticky d (tuple of tuples)",
(void*)STICKY_D},
{"refractD",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the refract d (tuple of tuples)",
(void*)REFRACT_D},
{"strandD",
(getter)ShadeInput_getAttribute, (setter)NULL,
"Get the strand d (tuple)",
(void*)STRAND_D},
{NULL,NULL,NULL,NULL,NULL} /* Sentinel */
};
PyTypeObject Node_Type = {
PyObject_HEAD_INIT( NULL ) /* required py macro */
0, /* ob_size */
/* For printing, in format "<module>.<name>" */
"Blender.Node.node", /* char *tp_name; */
sizeof( BPy_Node ), /* int tp_basicsize; */
0, /* tp_itemsize; For allocation */
/* Methods to implement standard operations */
NULL,/* destructor tp_dealloc; */
NULL, /* printfunc tp_print; */
NULL /*( getattrfunc ) PyObject_GenericGetAttr*/, /* getattrfunc tp_getattr; */
NULL /*( setattrfunc ) PyObject_GenericSetAttr*/, /* setattrfunc tp_setattr; */
( cmpfunc ) Node_compare, /* cmpfunc tp_compare; */
( reprfunc ) Node_repr, /* reprfunc tp_repr; */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* 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|Py_TPFLAGS_BASETYPE, /* 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 ***/
NULL, /*BPy_Node_methods,*/ /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
BPy_Node_getseters, /* struct PyGetSetDef *tp_getset; */
NULL, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)node_init, /* initproc tp_init; */
/*PyType_GenericAlloc*/NULL, /* allocfunc tp_alloc; */
node_new, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
PyTypeObject ShadeInput_Type = {
PyObject_HEAD_INIT( NULL ) /* required py macro */
0, /* ob_size */
/* For printing, in format "<module>.<name>" */
"Blender.Node.ShadeInput", /* char *tp_name; */
sizeof( BPy_ShadeInput ), /* int tp_basicsize; */
0, /* tp_itemsize; For allocation */
/* Methods to implement standard operations */
NULL,/* destructor tp_dealloc; */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
( cmpfunc ) ShadeInput_compare, /* cmpfunc tp_compare; */
( reprfunc ) ShadeInput_repr, /* reprfunc tp_repr; */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* 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 ***/
NULL, /*BPy_Node_methods,*/ /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
BPy_ShadeInput_getseters, /* struct PyGetSetDef *tp_getset; */
NULL, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
NULL, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
/* Initialise Node module */
PyObject *Node_Init(void)
{
PyObject *submodule;
if( PyType_Ready( &Node_Type ) < 0 )
return NULL;
if( PyType_Ready( &ShadeInput_Type ) < 0 )
return NULL;
if( PyType_Ready( &NodeSocket_Type ) < 0 )
return NULL;
if( PyType_Ready( &NodeSocketLists_Type ) < 0 )
return NULL;
if( PyType_Ready( &SockInMap_Type ) < 0 )
return NULL;
if( PyType_Ready( &SockOutMap_Type ) < 0 )
return NULL;
submodule = Py_InitModule3( "Blender.Node", NULL, "");
PyModule_AddIntConstant(submodule, "VALUE", SOCK_VALUE);
PyModule_AddIntConstant(submodule, "RGBA", SOCK_RGBA);
PyModule_AddIntConstant(submodule, "VECTOR", SOCK_VECTOR);
Py_INCREF(&NodeSocket_Type);
PyModule_AddObject(submodule, "Socket", (PyObject *)&NodeSocket_Type);
Py_INCREF(&Node_Type);
PyModule_AddObject(submodule, "Scripted", (PyObject *)&Node_Type);
return submodule;
}
static int Node_compare(BPy_Node *a, BPy_Node *b)
{
bNode *pa = a->node, *pb = b->node;
return (pa == pb) ? 0 : -1;
}
static PyObject *Node_repr(BPy_Node *self)
{
return PyString_FromFormat( "[Node \"%s\"]",
self->node ? self->node->id->name+2 : "empty node");
}
BPy_Node *Node_CreatePyObject(bNode *node)
{
BPy_Node *pynode;
pynode = (BPy_Node *)PyObject_NEW(BPy_Node, &Node_Type);
if(!pynode) {
fprintf(stderr,"Couldn't create BPy_Node object\n");
return (BPy_Node *)(EXPP_ReturnPyObjError(PyExc_MemoryError, "couldn't create BPy_Node object"));
}
pynode->node = node;
return pynode;
}
int pytype_is_pynode(PyObject *pyob)
{
return PyObject_TypeCheck(pyob, &Node_Type);
}
void InitNode(BPy_Node *self, bNode *node) {
self->node = node;
}
bNode *Node_FromPyObject(PyObject *pyobj)
{
return ((BPy_Node *)pyobj)->node;
}
void Node_SetStack(BPy_Node *self, bNodeStack **stack, int type)
{
if(type == NODE_INPUTSTACK) {
self->in = stack;
} else if(type == NODE_OUTPUTSTACK) {
self->out = stack;
}
}
void Node_SetShi(BPy_Node *self, ShadeInput *shi)
{
self->shi = shi;
}
/*********************/
static int ShadeInput_compare(BPy_ShadeInput *a, BPy_ShadeInput *b)
{
ShadeInput *pa = a->shi, *pb = b->shi;
return (pa == pb) ? 0 : -1;
}
static PyObject *ShadeInput_repr(BPy_ShadeInput *self)
{
return PyString_FromFormat( "[ShadeInput at \"%p\"]", self);
}
BPy_ShadeInput *ShadeInput_CreatePyObject(ShadeInput *shi)
{
BPy_ShadeInput *pyshi;
pyshi = (BPy_ShadeInput *)PyObject_NEW(BPy_ShadeInput, &ShadeInput_Type);
if(!pyshi) {
fprintf(stderr,"Couldn't create BPy_ShadeInput object\n");
return (BPy_ShadeInput *)(EXPP_ReturnPyObjError(PyExc_MemoryError, "couldn't create BPy_ShadeInput object"));
}
pyshi->shi = shi;
return pyshi;
}
View Git Blame Copy Permalink