Willian Padovani Germano
b7bf9bf1b7
* Added submodule Blender.Types:
Blender Type definitions can't be static anymore.
* Some cleanup of now unused defines in Camera.h and Lamp.h
1033 lines
33 KiB
C
1033 lines
33 KiB
C
/*
|
|
*
|
|
* ***** 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) 2001-2002 by NaN Holding BV.
|
|
* All rights reserved.
|
|
*
|
|
* This is a new part of Blender.
|
|
*
|
|
* Contributor(s): Willian P. Germano
|
|
*
|
|
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
|
*/
|
|
|
|
#include "Material.h"
|
|
|
|
/*****************************************************************************/
|
|
/* Function: M_Material_New */
|
|
/* Python equivalent: Blender.Material.New */
|
|
/*****************************************************************************/
|
|
static PyObject *M_Material_New(PyObject *self, PyObject *args, PyObject *keywords)
|
|
{
|
|
char *name = "Mat";
|
|
static char *kwlist[] = {"name", NULL};
|
|
C_Material *pymat; /* for Material Data object wrapper in Python */
|
|
Material *blmat; /* for actual Material Data we create in Blender */
|
|
char buf[21];
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, keywords, "|s", kwlist, &name))
|
|
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
|
|
"expected string or nothing as argument"));
|
|
|
|
if (strcmp(name, "Mat") != 0) /* use gave us a name ?*/
|
|
PyOS_snprintf(buf, sizeof(buf), "%s", name);
|
|
|
|
blmat = add_material(name); /* first create the Material Data in Blender */
|
|
|
|
if (blmat) /* now create the wrapper obj in Python */
|
|
pymat = (C_Material *)Material_createPyObject (blmat);
|
|
else
|
|
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't create Material Data in Blender"));
|
|
|
|
if (pymat == NULL)
|
|
return (EXPP_ReturnPyObjError (PyExc_MemoryError,
|
|
"couldn't create Material Data object"));
|
|
|
|
return (PyObject *)pymat;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* Function: M_Material_Get */
|
|
/* Python equivalent: Blender.Material.Get */
|
|
/* Description: Receives a string and returns the material whose */
|
|
/* name matches the string. If no argument is */
|
|
/* passed in, a list of all materials in the */
|
|
/* current scene is returned. */
|
|
/*****************************************************************************/
|
|
static PyObject *M_Material_Get(PyObject *self, PyObject *args)
|
|
{
|
|
char *name = NULL;
|
|
Material *mat_iter;
|
|
|
|
if (!PyArg_ParseTuple(args, "|s", &name))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected string argument (or nothing)"));
|
|
|
|
mat_iter = G.main->mat.first;
|
|
|
|
if (name) { /* (name) - Search material by name */
|
|
|
|
C_Material *wanted_mat = NULL;
|
|
|
|
while ((mat_iter) && (wanted_mat == NULL)) {
|
|
|
|
if (strcmp (name, mat_iter->id.name+2) == 0)
|
|
wanted_mat = (C_Material *)Material_createPyObject (mat_iter);
|
|
|
|
mat_iter = mat_iter->id.next;
|
|
}
|
|
|
|
if (wanted_mat == NULL) { /* Requested material doesn't exist */
|
|
char error_msg[64];
|
|
PyOS_snprintf(error_msg, sizeof(error_msg),
|
|
"Material \"%s\" not found", name);
|
|
return (EXPP_ReturnPyObjError (PyExc_NameError, error_msg));
|
|
}
|
|
|
|
return (PyObject *)wanted_mat;
|
|
}
|
|
|
|
else { /* () - return a list of all materials in the scene */
|
|
int index = 0;
|
|
PyObject *matlist, *pystr;
|
|
|
|
matlist = PyList_New (BLI_countlist (&(G.main->mat)));
|
|
|
|
if (matlist == NULL)
|
|
return (PythonReturnErrorObject (PyExc_MemoryError,
|
|
"couldn't create PyList"));
|
|
|
|
while (mat_iter) {
|
|
pystr = PyString_FromString (mat_iter->id.name+2);
|
|
|
|
if (!pystr)
|
|
return (PythonReturnErrorObject (PyExc_MemoryError,
|
|
"couldn't create PyString"));
|
|
|
|
PyList_SET_ITEM (matlist, index, pystr);
|
|
|
|
mat_iter = mat_iter->id.next;
|
|
index++;
|
|
}
|
|
|
|
return (matlist);
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* Function: M_Material_Init */
|
|
/*****************************************************************************/
|
|
PyObject *M_Material_Init (void)
|
|
{
|
|
PyObject *submodule;
|
|
|
|
submodule = Py_InitModule3("Blender.Material",
|
|
M_Material_methods, M_Material_doc);
|
|
|
|
return (submodule);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* Python C_Material methods: */
|
|
/*****************************************************************************/
|
|
static PyObject *Material_getName(C_Material *self)
|
|
{
|
|
PyObject *attr = PyString_FromString(self->material->id.name+2);
|
|
|
|
if (attr) return attr;
|
|
|
|
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.name attribute"));
|
|
}
|
|
|
|
static PyObject *Material_getMode(C_Material *self)
|
|
{
|
|
PyObject *attr = PyInt_FromLong((long)self->material->mode);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.Mode attribute");
|
|
}
|
|
|
|
static PyObject *Material_getRGBCol(C_Material *self)
|
|
{
|
|
return rgbTuple_getCol(self->rgb);
|
|
}
|
|
|
|
static PyObject *Material_getAmbCol(C_Material *self)
|
|
{
|
|
return rgbTuple_getCol(self->amb);
|
|
}
|
|
|
|
static PyObject *Material_getSpecCol(C_Material *self)
|
|
{
|
|
return rgbTuple_getCol(self->spec);
|
|
}
|
|
|
|
static PyObject *Material_getMirCol(C_Material *self)
|
|
{
|
|
return rgbTuple_getCol(self->mir);
|
|
}
|
|
|
|
static PyObject *Material_getAmb(C_Material *self)
|
|
{
|
|
PyObject *attr = PyFloat_FromDouble((double)self->material->amb);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.amb attribute");
|
|
}
|
|
|
|
static PyObject *Material_getEmit(C_Material *self)
|
|
{
|
|
PyObject *attr = PyFloat_FromDouble((double)self->material->emit);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.emit attribute");
|
|
}
|
|
|
|
static PyObject *Material_getAng(C_Material *self)
|
|
{
|
|
PyObject *attr = PyFloat_FromDouble((double)self->material->ang);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.ang attribute");
|
|
}
|
|
|
|
static PyObject *Material_getAlpha(C_Material *self)
|
|
{
|
|
PyObject *attr = PyFloat_FromDouble((double)self->material->alpha);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.alpha attribute");
|
|
}
|
|
|
|
static PyObject *Material_getRef(C_Material *self)
|
|
{
|
|
PyObject *attr = PyFloat_FromDouble((double)self->material->ref);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.ref attribute");
|
|
}
|
|
|
|
static PyObject *Material_getSpec(C_Material *self)
|
|
{
|
|
PyObject *attr = PyFloat_FromDouble((double)self->material->spec);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.spec attribute");
|
|
}
|
|
|
|
static PyObject *Material_getSpecTransp(C_Material *self)
|
|
{
|
|
PyObject *attr = PyFloat_FromDouble((double)self->material->spectra);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.specTransp attribute");
|
|
}
|
|
|
|
static PyObject *Material_getAdd(C_Material *self)
|
|
{
|
|
PyObject *attr = PyFloat_FromDouble((double)self->material->add);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.add attribute");
|
|
}
|
|
|
|
static PyObject *Material_getZOffset(C_Material *self)
|
|
{
|
|
PyObject *attr = PyFloat_FromDouble((double)self->material->zoffs);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.zOffset attribute");
|
|
}
|
|
|
|
static PyObject *Material_getHaloSize(C_Material *self)
|
|
{
|
|
PyObject *attr = PyFloat_FromDouble((double)self->material->hasize);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.haloSize attribute");
|
|
}
|
|
|
|
static PyObject *Material_getFlareSize(C_Material *self)
|
|
{
|
|
PyObject *attr = PyFloat_FromDouble((double)self->material->flaresize);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.flareSize attribute");
|
|
}
|
|
|
|
static PyObject *Material_getFlareBoost(C_Material *self)
|
|
{
|
|
PyObject *attr = PyFloat_FromDouble((double)self->material->flareboost);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.flareBoost attribute");
|
|
}
|
|
|
|
static PyObject *Material_getSubSize(C_Material *self)
|
|
{
|
|
PyObject *attr = PyFloat_FromDouble((double)self->material->subsize);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.subSize attribute");
|
|
}
|
|
|
|
static PyObject *Material_getHardness(C_Material *self)
|
|
{
|
|
PyObject *attr = PyInt_FromLong((long)self->material->har);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.hard attribute");
|
|
}
|
|
|
|
static PyObject *Material_getNFlares(C_Material *self)
|
|
{
|
|
PyObject *attr = PyInt_FromLong((long)self->material->flarec);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.nFlares attribute");
|
|
}
|
|
|
|
static PyObject *Material_getNStars(C_Material *self)
|
|
{
|
|
PyObject *attr = PyInt_FromLong((long)self->material->starc);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.nStars attribute");
|
|
}
|
|
|
|
static PyObject *Material_getNLines(C_Material *self)
|
|
{
|
|
PyObject *attr = PyInt_FromLong((long)self->material->linec);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.nLines attribute");
|
|
}
|
|
|
|
static PyObject *Material_getNRings(C_Material *self)
|
|
{
|
|
PyObject *attr = PyInt_FromLong((long)self->material->ringc);
|
|
|
|
if (attr) return attr;
|
|
|
|
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Material.nRings attribute");
|
|
}
|
|
|
|
static PyObject *Material_setName(C_Material *self, PyObject *args)
|
|
{
|
|
char *name;
|
|
char buf[21];
|
|
|
|
if (!PyArg_ParseTuple(args, "s", &name))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected string argument"));
|
|
|
|
PyOS_snprintf(buf, sizeof(buf), "%s", name);
|
|
|
|
rename_id(&self->material->id, buf);
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* Possible modes are traceable, shadow, shadeless, wire, vcolLight,
|
|
* vcolPaint, halo, ztransp, zinvert, haloRings, env, haloLines,
|
|
* onlyShadow, xalpha, star, faceTexture, haloTex, haloPuno, noMist,
|
|
* haloShade, haloFlare */
|
|
static PyObject *Material_setMode(C_Material *self, PyObject *args)
|
|
{
|
|
int i, flag = 0;
|
|
char *m[21] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL,
|
|
NULL, NULL, NULL, NULL, NULL, NULL, NULL,
|
|
NULL, NULL, NULL, NULL, NULL, NULL, NULL};
|
|
|
|
if (!PyArg_ParseTuple(args, "|sssssssssssssssssssss",
|
|
&m[0], &m[1], &m[2], &m[3], &m[4], &m[5], &m[6],
|
|
&m[7], &m[8], &m[9], &m[10], &m[11], &m[12], &m[13],
|
|
&m[14], &m[15], &m[16], &m[17], &m[18], &m[19], &m[20]))
|
|
{
|
|
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
|
|
"expected from none to 21 string argument(s)"));
|
|
}
|
|
|
|
for (i = 0; i < 21; i++) {
|
|
if (m[i] == NULL) break;
|
|
if (strcmp(m[i], "Traceable") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_TRACEABLE;
|
|
else if (strcmp(m[i], "Shadow") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_SHADOW;
|
|
else if (strcmp(m[i], "Shadeless") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_SHADELESS;
|
|
else if (strcmp(m[i], "Wire") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_WIRE;
|
|
else if (strcmp(m[i], "VColLight") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_VCOLLIGHT;
|
|
else if (strcmp(m[i], "VColPaint") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_VCOLPAINT;
|
|
else if (strcmp(m[i], "Halo") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_HALO;
|
|
else if (strcmp(m[i], "ZTransp") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_ZTRANSP;
|
|
else if (strcmp(m[i], "ZInvert") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_ZINVERT;
|
|
else if (strcmp(m[i], "HaloRings") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_HALORINGS;
|
|
else if (strcmp(m[i], "Env") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_ENV;
|
|
else if (strcmp(m[i], "HaloLines") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_HALOLINES;
|
|
else if (strcmp(m[i], "OnlyShadow") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_ONLYSHADOW;
|
|
else if (strcmp(m[i], "XAlpha") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_XALPHA;
|
|
else if (strcmp(m[i], "Star") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_STAR;
|
|
else if (strcmp(m[i], "FaceTex") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_FACETEX;
|
|
else if (strcmp(m[i], "HaloTex") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_HALOTEX;
|
|
else if (strcmp(m[i], "HaloPuno") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_HALOPUNO;
|
|
else if (strcmp(m[i], "NoMist") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_NOMIST;
|
|
else if (strcmp(m[i], "HaloShade") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_HALOSHADE;
|
|
else if (strcmp(m[i], "HaloFlare") == 0)
|
|
flag |= (short)EXPP_MAT_MODE_HALOFLARE;
|
|
else
|
|
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
|
|
"unknown Material mode argument"));
|
|
}
|
|
|
|
self->material->mode = flag;
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* Another helper function, for the same reason.
|
|
* (See comment before Material_setIntType above). */
|
|
static PyObject *Material_setIntMode(C_Material *self, PyObject *args)
|
|
{
|
|
int value;
|
|
|
|
if (!PyArg_ParseTuple(args, "i", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected int argument"));
|
|
|
|
self->material->mode = value;
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static PyObject *Material_setRGBCol (C_Material *self, PyObject *args)
|
|
{
|
|
return rgbTuple_setCol(self->rgb, args);
|
|
}
|
|
|
|
static PyObject *Material_setAmbCol (C_Material *self, PyObject *args)
|
|
{
|
|
return rgbTuple_setCol(self->amb, args);
|
|
}
|
|
|
|
static PyObject *Material_setSpecCol (C_Material *self, PyObject *args)
|
|
{
|
|
return rgbTuple_setCol(self->spec, args);
|
|
}
|
|
|
|
static PyObject *Material_setMirCol (C_Material *self, PyObject *args)
|
|
{
|
|
return rgbTuple_setCol(self->mir, args);
|
|
}
|
|
|
|
static PyObject *Material_setColorComponent(C_Material *self, char *key,
|
|
PyObject *args)
|
|
{ /* for compatibility with old bpython */
|
|
float value;
|
|
|
|
if (!PyArg_ParseTuple(args, "f", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected float argument in [0.0, 1.0]"));
|
|
|
|
value = EXPP_ClampFloat (value, EXPP_MAT_COL_MIN,
|
|
EXPP_MAT_COL_MAX);
|
|
|
|
if (!strcmp(key, "R"))
|
|
self->material->r = value;
|
|
else if (!strcmp(key, "G"))
|
|
self->material->g = value;
|
|
else if (!strcmp(key, "B"))
|
|
self->material->b = value;
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setAmb(C_Material *self, PyObject *args)
|
|
{
|
|
float value;
|
|
|
|
if (!PyArg_ParseTuple(args, "f", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected float argument in [0.0, 1.0]"));
|
|
|
|
self->material->amb = EXPP_ClampFloat (value, EXPP_MAT_AMB_MIN,
|
|
EXPP_MAT_AMB_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setEmit(C_Material *self, PyObject *args)
|
|
{
|
|
float value;
|
|
|
|
if (!PyArg_ParseTuple(args, "f", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected float argument in [0.0, 1.0]"));
|
|
|
|
self->material->emit = EXPP_ClampFloat (value, EXPP_MAT_EMIT_MIN,
|
|
EXPP_MAT_EMIT_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setAng(C_Material *self, PyObject *args)
|
|
{
|
|
float value;
|
|
|
|
if (!PyArg_ParseTuple(args, "f", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected float argument in [0.0, 1.0]"));
|
|
|
|
self->material->ang = EXPP_ClampFloat (value, EXPP_MAT_ANG_MIN,
|
|
EXPP_MAT_ANG_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setSpecTransp(C_Material *self, PyObject *args)
|
|
{
|
|
float value;
|
|
|
|
if (!PyArg_ParseTuple(args, "f", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected float argument in [0.0, 1.0]"));
|
|
|
|
self->material->spectra = EXPP_ClampFloat (value, EXPP_MAT_SPECTRA_MIN,
|
|
EXPP_MAT_SPECTRA_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setAlpha(C_Material *self, PyObject *args)
|
|
{
|
|
float value;
|
|
|
|
if (!PyArg_ParseTuple(args, "f", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected float argument in [0.0, 1.0]"));
|
|
|
|
self->material->alpha = EXPP_ClampFloat (value, EXPP_MAT_ALPHA_MIN,
|
|
EXPP_MAT_ALPHA_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setRef(C_Material *self, PyObject *args)
|
|
{
|
|
float value;
|
|
|
|
if (!PyArg_ParseTuple(args, "f", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected float argument in [0.0, 1.0]"));
|
|
|
|
self->material->ref = EXPP_ClampFloat (value, EXPP_MAT_REF_MIN,
|
|
EXPP_MAT_REF_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setSpec(C_Material *self, PyObject *args)
|
|
{
|
|
float value;
|
|
|
|
if (!PyArg_ParseTuple(args, "f", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected float argument in [0.0, 1.0]"));
|
|
|
|
self->material->spec = EXPP_ClampFloat (value, EXPP_MAT_SPEC_MIN,
|
|
EXPP_MAT_SPEC_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setZOffset(C_Material *self, PyObject *args)
|
|
{
|
|
float value;
|
|
|
|
if (!PyArg_ParseTuple(args, "f", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected float argument in [0.0, 10.0]"));
|
|
|
|
self->material->zoffs = EXPP_ClampFloat (value, EXPP_MAT_ZOFFS_MIN,
|
|
EXPP_MAT_ZOFFS_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setAdd(C_Material *self, PyObject *args)
|
|
{
|
|
float value;
|
|
|
|
if (!PyArg_ParseTuple(args, "f", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected float argument in [0.0, 1.0]"));
|
|
|
|
self->material->add = EXPP_ClampFloat (value, EXPP_MAT_ADD_MIN,
|
|
EXPP_MAT_ADD_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setHaloSize(C_Material *self, PyObject *args)
|
|
{
|
|
float value;
|
|
|
|
if (!PyArg_ParseTuple(args, "f", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected float argument in [0.0, 100.0]"));
|
|
|
|
self->material->hasize = EXPP_ClampFloat (value, EXPP_MAT_HALOSIZE_MIN,
|
|
EXPP_MAT_HALOSIZE_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setFlareSize(C_Material *self, PyObject *args)
|
|
{
|
|
float value;
|
|
|
|
if (!PyArg_ParseTuple(args, "f", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected float argument in [0.1, 25.0]"));
|
|
|
|
self->material->flaresize = EXPP_ClampFloat (value, EXPP_MAT_FLARESIZE_MIN,
|
|
EXPP_MAT_FLARESIZE_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setFlareBoost(C_Material *self, PyObject *args)
|
|
{
|
|
float value;
|
|
|
|
if (!PyArg_ParseTuple(args, "f", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected float argument in [0.1, 10.0]"));
|
|
|
|
self->material->flareboost = EXPP_ClampFloat(value, EXPP_MAT_FLAREBOOST_MIN,
|
|
EXPP_MAT_FLAREBOOST_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setSubSize(C_Material *self, PyObject *args)
|
|
{
|
|
float value;
|
|
|
|
if (!PyArg_ParseTuple(args, "f", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected float argument in [0.1, 25.0]"));
|
|
|
|
self->material->subsize = EXPP_ClampFloat (value, EXPP_MAT_SUBSIZE_MIN,
|
|
EXPP_MAT_SUBSIZE_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setHardness(C_Material *self, PyObject *args)
|
|
{
|
|
short value;
|
|
|
|
if (!PyArg_ParseTuple(args, "h", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected int argument in [1, 255]"));
|
|
|
|
self->material->har = EXPP_ClampInt (value, EXPP_MAT_HARD_MIN,
|
|
EXPP_MAT_HARD_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setNFlares(C_Material *self, PyObject *args)
|
|
{
|
|
short value;
|
|
|
|
if (!PyArg_ParseTuple(args, "h", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected int argument in [1, 32]"));
|
|
|
|
self->material->flarec = EXPP_ClampInt (value, EXPP_MAT_NFLARES_MIN,
|
|
EXPP_MAT_NFLARES_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setNStars(C_Material *self, PyObject *args)
|
|
{
|
|
short value;
|
|
|
|
if (!PyArg_ParseTuple(args, "h", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected int argument in [3, 50]"));
|
|
|
|
self->material->starc = EXPP_ClampInt (value, EXPP_MAT_NSTARS_MIN,
|
|
EXPP_MAT_NSTARS_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setNLines(C_Material *self, PyObject *args)
|
|
{
|
|
short value;
|
|
|
|
if (!PyArg_ParseTuple(args, "h", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected int argument in [0, 250]"));
|
|
|
|
self->material->linec = EXPP_ClampInt (value, EXPP_MAT_NLINES_MIN,
|
|
EXPP_MAT_NLINES_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
static PyObject *Material_setNRings(C_Material *self, PyObject *args)
|
|
{
|
|
short value;
|
|
|
|
if (!PyArg_ParseTuple(args, "h", &value))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected int argument in [0, 24]"));
|
|
|
|
self->material->ringc = EXPP_ClampInt (value, EXPP_MAT_NRINGS_MIN,
|
|
EXPP_MAT_NRINGS_MAX);
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* Function: Material_createPyObject */
|
|
/* Description: This function will create a new C_Material from an existing */
|
|
/* Blender material structure. */
|
|
/*****************************************************************************/
|
|
static PyObject *Material_createPyObject (Material *mat)
|
|
{
|
|
C_Material *pymat;
|
|
float *rgb[3], *amb[3], *spec[3], *mir[3];
|
|
|
|
pymat = (C_Material *)PyObject_NEW (C_Material, &Material_Type);
|
|
|
|
if (!pymat)
|
|
return EXPP_ReturnPyObjError (PyExc_MemoryError,
|
|
"couldn't create C_Material object");
|
|
|
|
pymat->material = mat;
|
|
|
|
rgb[0] = &mat->r;
|
|
rgb[1] = &mat->g;
|
|
rgb[2] = &mat->b;
|
|
|
|
amb[0] = &mat->ambr;
|
|
amb[1] = &mat->ambg;
|
|
amb[2] = &mat->ambb;
|
|
|
|
spec[0] = &mat->specr;
|
|
spec[1] = &mat->specg;
|
|
spec[2] = &mat->specb;
|
|
|
|
mir[0] = &mat->mirr;
|
|
mir[1] = &mat->mirg;
|
|
mir[2] = &mat->mirb;
|
|
|
|
pymat->rgb = (C_rgbTuple *)rgbTuple_New(rgb);
|
|
pymat->amb = (C_rgbTuple *)rgbTuple_New(amb);
|
|
pymat->spec = (C_rgbTuple *)rgbTuple_New(spec);
|
|
pymat->mir = (C_rgbTuple *)rgbTuple_New(mir);
|
|
|
|
return (PyObject *)pymat;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* Function: MaterialDeAlloc */
|
|
/* Description: This is a callback function for the C_Material type. It is */
|
|
/* the destructor function. */
|
|
/*****************************************************************************/
|
|
static void MaterialDeAlloc (C_Material *self)
|
|
{
|
|
PyObject_DEL (self);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* Function: MaterialGetAttr */
|
|
/* Description: This is a callback function for the C_Material type. It is */
|
|
/* the function that accesses C_Material "member variables" and */
|
|
/* methods. */
|
|
/*****************************************************************************/
|
|
static PyObject *MaterialGetAttr (C_Material *self, char *name)
|
|
{
|
|
PyObject *attr = Py_None;
|
|
|
|
if (strcmp(name, "name") == 0)
|
|
attr = PyString_FromString(self->material->id.name+2);
|
|
else if (strcmp(name, "mode") == 0)
|
|
attr = PyInt_FromLong(self->material->mode);
|
|
else if (strcmp(name, "rgbCol") == 0)
|
|
attr = Material_getRGBCol(self);
|
|
else if (strcmp(name, "ambCol") == 0)
|
|
attr = Material_getAmbCol(self);
|
|
else if (strcmp(name, "specCol") == 0)
|
|
attr = Material_getSpecCol(self);
|
|
else if (strcmp(name, "mirCol") == 0)
|
|
attr = Material_getMirCol(self);
|
|
else if (strcmp(name, "R") == 0)
|
|
attr = PyFloat_FromDouble((double)self->material->r);
|
|
else if (strcmp(name, "G") == 0)
|
|
attr = PyFloat_FromDouble((double)self->material->g);
|
|
else if (strcmp(name, "B") == 0)
|
|
attr = PyFloat_FromDouble((double)self->material->b);
|
|
else if (strcmp(name, "amb") == 0)
|
|
attr = PyFloat_FromDouble((double)self->material->amb);
|
|
else if (strcmp(name, "ang") == 0)
|
|
attr = PyFloat_FromDouble((double)self->material->ang);
|
|
else if (strcmp(name, "emit") == 0)
|
|
attr = PyFloat_FromDouble((double)self->material->emit);
|
|
else if (strcmp(name, "alpha") == 0)
|
|
attr = PyFloat_FromDouble((double)self->material->alpha);
|
|
else if (strcmp(name, "ref") == 0)
|
|
attr = PyFloat_FromDouble((double)self->material->ref);
|
|
else if (strcmp(name, "spec") == 0)
|
|
attr = PyFloat_FromDouble((double)self->material->spec);
|
|
else if (strcmp(name, "specTransp") == 0)
|
|
attr = PyFloat_FromDouble((double)self->material->spectra);
|
|
else if (strcmp(name, "add") == 0)
|
|
attr = PyFloat_FromDouble((double)self->material->add);
|
|
else if (strcmp(name, "zOffset") == 0)
|
|
attr = PyFloat_FromDouble((double)self->material->zoffs);
|
|
else if (strcmp(name, "haloSize") == 0)
|
|
attr = PyFloat_FromDouble((double)self->material->hasize);
|
|
else if (strcmp(name, "flareSize") == 0)
|
|
attr = PyFloat_FromDouble((double)self->material->flaresize);
|
|
else if (strcmp(name, "flareBoost") == 0)
|
|
attr = PyFloat_FromDouble((double)self->material->flareboost);
|
|
else if (strcmp(name, "subSize") == 0)
|
|
attr = PyFloat_FromDouble((double)self->material->subsize);
|
|
else if (strcmp(name, "hard") == 0)
|
|
attr = PyInt_FromLong((long)self->material->har);
|
|
else if (strcmp(name, "nFlares") == 0)
|
|
attr = PyInt_FromLong((long)self->material->flarec);
|
|
else if (strcmp(name, "nStars") == 0)
|
|
attr = PyInt_FromLong((long)self->material->starc);
|
|
else if (strcmp(name, "nLines") == 0)
|
|
attr = PyInt_FromLong((long)self->material->linec);
|
|
else if (strcmp(name, "nRings") == 0)
|
|
attr = PyInt_FromLong((long)self->material->ringc);
|
|
|
|
else if (strcmp(name, "__members__") == 0) {
|
|
attr = /* 27 items */
|
|
Py_BuildValue("[s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s]",
|
|
"name", "mode", "rgbCol", "ambCol", "specCol", "mirCol",
|
|
"R", "G", "B", "alpha", "amb", "ang", "emit", "ref",
|
|
"spec", "specTransp", "add", "zOffset", "haloSize",
|
|
"flareSize", "flareBoost", "subSize", "hard", "nFlares",
|
|
"nStars", "nLines", "nRings");
|
|
}
|
|
|
|
if (!attr)
|
|
return (EXPP_ReturnPyObjError (PyExc_MemoryError,
|
|
"couldn't create PyObject"));
|
|
|
|
if (attr != Py_None) return attr; /* member attribute found, return it */
|
|
|
|
/* not an attribute, search the methods table */
|
|
return Py_FindMethod(C_Material_methods, (PyObject *)self, name);
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* Function: MaterialSetAttr */
|
|
/* Description: This is a callback function for the C_Material type. */
|
|
/* It is the function that sets Material attributes (member */
|
|
/* variables). */
|
|
/****************************************************************************/
|
|
static int MaterialSetAttr (C_Material *self, char *name, PyObject *value)
|
|
{
|
|
PyObject *valtuple;
|
|
PyObject *error = NULL;
|
|
|
|
/* We're playing a trick on the Python API users here. Even if they use
|
|
* Material.member = val instead of Material.setMember(val), we end up using the
|
|
* function anyway, since it already has error checking, clamps to the right
|
|
* interval and updates the Blender Material structure when necessary. */
|
|
|
|
/* First we put "value" in a tuple, because we want to pass it to functions
|
|
* that only accept PyTuples. Using "N" doesn't increment value's ref count */
|
|
valtuple = Py_BuildValue("(N)", value);
|
|
|
|
if (!valtuple) /* everything OK with our PyObject? */
|
|
return EXPP_ReturnIntError(PyExc_MemoryError,
|
|
"MaterialSetAttr: couldn't create PyTuple");
|
|
|
|
/* Now we just compare "name" with all possible C_Material member variables */
|
|
if (strcmp (name, "name") == 0)
|
|
error = Material_setName (self, valtuple);
|
|
else if (strcmp (name, "mode") == 0)
|
|
error = Material_setIntMode (self, valtuple); /* special case */
|
|
else if (strcmp (name, "rgbCol") == 0)
|
|
error = Material_setRGBCol (self, valtuple);
|
|
else if (strcmp (name, "ambCol") == 0)
|
|
error = Material_setAmbCol (self, valtuple);
|
|
else if (strcmp (name, "specCol") == 0)
|
|
error = Material_setSpecCol (self, valtuple);
|
|
else if (strcmp (name, "mirCol") == 0)
|
|
error = Material_setMirCol (self, valtuple);
|
|
else if (strcmp (name, "R") == 0)
|
|
error = Material_setColorComponent (self, "R", valtuple);
|
|
else if (strcmp (name, "G") == 0)
|
|
error = Material_setColorComponent (self, "G", valtuple);
|
|
else if (strcmp (name, "B") == 0)
|
|
error = Material_setColorComponent (self, "B", valtuple);
|
|
else if (strcmp (name, "amb") == 0)
|
|
error = Material_setAmb (self, valtuple);
|
|
else if (strcmp (name, "ang") == 0)
|
|
error = Material_setAng (self, valtuple);
|
|
else if (strcmp (name, "emit") == 0)
|
|
error = Material_setEmit (self, valtuple);
|
|
else if (strcmp (name, "alpha") == 0)
|
|
error = Material_setAlpha (self, valtuple);
|
|
else if (strcmp (name, "ref") == 0)
|
|
error = Material_setRef (self, valtuple);
|
|
else if (strcmp (name, "spec") == 0)
|
|
error = Material_setSpec (self, valtuple);
|
|
else if (strcmp (name, "specTransp") == 0)
|
|
error = Material_setSpecTransp (self, valtuple);
|
|
else if (strcmp (name, "add") == 0)
|
|
error = Material_setAdd (self, valtuple);
|
|
else if (strcmp (name, "zOffset") == 0)
|
|
error = Material_setZOffset (self, valtuple);
|
|
else if (strcmp (name, "haloSize") == 0)
|
|
error = Material_setHaloSize (self, valtuple);
|
|
else if (strcmp (name, "flareSize") == 0)
|
|
error = Material_setFlareSize (self, valtuple);
|
|
else if (strcmp (name, "flareBoost") == 0)
|
|
error = Material_setFlareBoost (self, valtuple);
|
|
else if (strcmp (name, "subSize") == 0)
|
|
error = Material_setSubSize (self, valtuple);
|
|
else if (strcmp (name, "hard") == 0)
|
|
error = Material_setHardness (self, valtuple);
|
|
else if (strcmp (name, "nFlares") == 0)
|
|
error = Material_setNFlares (self, valtuple);
|
|
else if (strcmp (name, "nStars") == 0)
|
|
error = Material_setNStars (self, valtuple);
|
|
else if (strcmp (name, "nLines") == 0)
|
|
error = Material_setNLines (self, valtuple);
|
|
else if (strcmp (name, "nRings") == 0)
|
|
error = Material_setNRings (self, valtuple);
|
|
|
|
else { /* Error */
|
|
Py_DECREF(valtuple);
|
|
return (EXPP_ReturnIntError (PyExc_AttributeError, name));
|
|
}
|
|
|
|
/* valtuple won't be returned to the caller, so we need to DECREF it */
|
|
Py_DECREF(valtuple);
|
|
|
|
if (error != Py_None) return -1;
|
|
|
|
/* Py_None was incref'ed by the called Material_set* function. We probably
|
|
* don't need to decref Py_None (!), but since Python/C API manual tells us
|
|
* to treat it like any other PyObject regarding ref counting ... */
|
|
Py_DECREF(Py_None);
|
|
return 0; /* normal exit */
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* Function: MaterialPrint */
|
|
/* Description: This is a callback function for the C_Material type. It */
|
|
/* builds a meaninful string to 'print' material objects. */
|
|
/*****************************************************************************/
|
|
static int MaterialPrint(C_Material *self, FILE *fp, int flags)
|
|
{
|
|
fprintf(fp, "[Material \"%s\"]", self->material->id.name+2);
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* Function: MaterialRepr */
|
|
/* Description: This is a callback function for the C_Material type. It */
|
|
/* builds a meaninful string to represent material objects. */
|
|
/*****************************************************************************/
|
|
static PyObject *MaterialRepr (C_Material *self)
|
|
{
|
|
char buf[40];
|
|
|
|
PyOS_snprintf(buf, sizeof(buf), "[Material \"%s\"]",
|
|
self->material->id.name+2);
|
|
|
|
return PyString_FromString(buf);
|
|
}
|