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
8ccd19ec184d4d29353027f9a8dfbb6d64f9383c
blender-archive/source/blender/python/api2_2x/Curve.c

1449 lines
42 KiB
C
Raw Normal View History

* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
/*
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
* $Id$
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
* ***** 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.
*
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
* Contributor(s): Jacques Guignot, Stephen Swaney
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
*
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
#include <Python.h>
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
#include "Curve.h"
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
#include <stdio.h>
#include <BLI_arithb.h>
#include <BLI_blenlib.h>
#include <BKE_main.h>
#include <BKE_global.h>
#include <BKE_object.h>
#include <BKE_library.h>
#include <BKE_curve.h>
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
#include <BKE_utildefines.h>
#include <MEM_guardedalloc.h> /* because we wil be mallocing memory */
#include "CurNurb.h"
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
#include "gen_utils.h"
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
#include "modules.h"
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
/*****************************************************************************/
/* The following string definitions are used for documentation strings. */
/* In Python these will be written to the console when doing a */
/* Blender.Curve.__doc__ */
/*****************************************************************************/
char M_Curve_doc[] = "The Blender Curve module\n\n\
This module provides access to **Curve Data** in Blender.\n\
Functions :\n\
New(opt name) : creates a new curve object with the given name (optional)\n\
Get(name) : retreives a curve with the given name (mandatory)\n\
get(name) : same as Get. Kept for compatibility reasons";
char M_Curve_New_doc[] = "";
char M_Curve_Get_doc[] = "xxx";
/*****************************************************************************/
/* Python API function prototypes for the Curve module. */
/*****************************************************************************/
static PyObject *M_Curve_New (PyObject * self, PyObject * args);
static PyObject *M_Curve_Get (PyObject * self, PyObject * args);
/*****************************************************************************/
/* Python BPy_Curve instance methods declarations: */
/*****************************************************************************/
static PyObject *Curve_getName (BPy_Curve * self);
static PyObject *Curve_setName (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getPathLen (BPy_Curve * self);
static PyObject *Curve_setPathLen (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getTotcol (BPy_Curve * self);
static PyObject *Curve_setTotcol (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getMode (BPy_Curve * self);
static PyObject *Curve_setMode (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getBevresol (BPy_Curve * self);
static PyObject *Curve_setBevresol (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getResolu (BPy_Curve * self);
static PyObject *Curve_setResolu (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getResolv (BPy_Curve * self);
static PyObject *Curve_setResolv (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getWidth (BPy_Curve * self);
static PyObject *Curve_setWidth (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getExt1 (BPy_Curve * self);
static PyObject *Curve_setExt1 (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getExt2 (BPy_Curve * self);
static PyObject *Curve_setExt2 (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getControlPoint (BPy_Curve * self, PyObject * args);
static PyObject *Curve_setControlPoint (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getLoc (BPy_Curve * self);
static PyObject *Curve_setLoc (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getRot (BPy_Curve * self);
static PyObject *Curve_setRot (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getSize (BPy_Curve * self);
static PyObject *Curve_setSize (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getNumCurves (BPy_Curve * self);
static PyObject *Curve_isNurb (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getNumPoints (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getNumPoints (BPy_Curve * self, PyObject * args);
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_appendPoint (BPy_Curve * self, PyObject * args);
static PyObject *Curve_getMaterials (BPy_Curve * self);
static PyObject *Curve_getIter (BPy_Curve * self);
static PyObject *Curve_iterNext (BPy_Curve * self);
static PyObject *Curve_update (BPy_Curve * self);
PyObject *Curve_getNurb (BPy_Curve * self, int n);
static int Curve_length (PyInstanceObject * inst);
void update_displists( void* data );
void makeDispList(Object *ob);
struct chartrans *text_to_curve(Object *ob, int mode);
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
/*****************************************************************************/
/* Python method definitions for Blender.Curve module: */
/*****************************************************************************/
struct PyMethodDef M_Curve_methods[] = {
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
{"New", (PyCFunction) M_Curve_New, METH_VARARGS, M_Curve_New_doc},
{"Get", M_Curve_Get, METH_VARARGS, M_Curve_Get_doc},
{"get", M_Curve_Get, METH_VARARGS, M_Curve_Get_doc},
{NULL, NULL, 0, NULL}
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
};
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
/*****************************************************************************/
/* Python BPy_Curve instance methods table: */
/*****************************************************************************/
static PyMethodDef BPy_Curve_methods[] = {
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
{"getName", (PyCFunction) Curve_getName,
METH_NOARGS, "() - Return Curve Data name"},
{"setName", (PyCFunction) Curve_setName,
METH_VARARGS, "() - Sets Curve Data name"},
{"getPathLen", (PyCFunction) Curve_getPathLen,
METH_NOARGS, "() - Return Curve path length"},
{"setPathLen", (PyCFunction) Curve_setPathLen,
METH_VARARGS, "(int) - Sets Curve path length"},
{"getTotcol", (PyCFunction) Curve_getTotcol,
METH_NOARGS, "() - Return the number of materials of the curve"},
{"setTotcol", (PyCFunction) Curve_setTotcol,
METH_VARARGS, "(int) - Sets the number of materials of the curve"},
{"getFlag", (PyCFunction) Curve_getMode,
METH_NOARGS, "() - Return flag (see the doc for semantic)"},
{"setFlag", (PyCFunction) Curve_setMode,
METH_VARARGS, "(int) - Sets flag (see the doc for semantic)"},
{"getBevresol", (PyCFunction) Curve_getBevresol,
METH_NOARGS, "() - Return bevel resolution"},
{"setBevresol", (PyCFunction) Curve_setBevresol,
METH_VARARGS, "(int) - Sets bevel resolution"},
{"getResolu", (PyCFunction) Curve_getResolu,
METH_NOARGS, "() - Return U resolution"},
{"setResolu", (PyCFunction) Curve_setResolu,
METH_VARARGS, "(int) - Sets U resolution"},
{"getResolv", (PyCFunction) Curve_getResolv,
METH_NOARGS, "() - Return V resolution"},
{"setResolv", (PyCFunction) Curve_setResolv,
METH_VARARGS, "(int) - Sets V resolution"},
{"getWidth", (PyCFunction) Curve_getWidth,
METH_NOARGS, "() - Return curve width"},
{"setWidth", (PyCFunction) Curve_setWidth,
METH_VARARGS, "(int) - Sets curve width"},
{"getExt1", (PyCFunction) Curve_getExt1,
METH_NOARGS, "() - Returns extent 1 of the bevel"},
{"setExt1", (PyCFunction) Curve_setExt1,
METH_VARARGS, "(int) - Sets extent 1 of the bevel"},
{"getExt2", (PyCFunction) Curve_getExt2,
METH_NOARGS, "() - Return extent 2 of the bevel "},
{"setExt2", (PyCFunction) Curve_setExt2,
METH_VARARGS, "(int) - Sets extent 2 of the bevel "},
{"getControlPoint", (PyCFunction) Curve_getControlPoint,
METH_VARARGS, "(int numcurve,int numpoint) -\
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
Gets a control point.Depending upon the curve type, returne a list of 4 or 9 floats"},
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
{"setControlPoint", (PyCFunction) Curve_setControlPoint,
METH_VARARGS, "(int numcurve,int numpoint,float x,float y,float z,\
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
float w)(nurbs) or (int numcurve,int numpoint,float x1,...,x9(bezier)\
Sets a control point "},
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
{"getLoc", (PyCFunction) Curve_getLoc,
METH_NOARGS, "() - Gets Location of the curve (a 3-tuple) "},
{"setLoc", (PyCFunction) Curve_setLoc,
METH_VARARGS, "(3-tuple) - Sets Location "},
{"getRot", (PyCFunction) Curve_getRot,
METH_NOARGS, "() - Gets curve rotation"},
{"setRot", (PyCFunction) Curve_setRot,
METH_VARARGS, "(3-tuple) - Sets curve rotation"},
{"getSize", (PyCFunction) Curve_getSize,
METH_NOARGS, "() - Gets curve size"},
{"setSize", (PyCFunction) Curve_setSize,
METH_VARARGS, "(3-tuple) - Sets curve size"},
{"getNumCurves", (PyCFunction) Curve_getNumCurves,
METH_NOARGS, "() - Gets number of curves in Curve"},
{"isNurb", (PyCFunction) Curve_isNurb,
METH_VARARGS,
"(nothing or integer) - returns 1 if curve is type Nurb, O otherwise."},
{"getNumPoints", (PyCFunction) Curve_getNumPoints,
METH_VARARGS,
"(nothing or integer) - returns the number of points of the specified curve"},
{"appendPoint", (PyCFunction) Curve_appendPoint, METH_VARARGS,
"( int numcurve, list of coordinates) - adds a new point to end of curve"},
{"update", (PyCFunction) Curve_update, METH_NOARGS,
"( ) - updates display lists after changes to Curve"},
{"getMaterials", (PyCFunction) Curve_getMaterials, METH_NOARGS,
"() - returns list of materials assigned to this Curve"},
#if 0
// fixme
{"getIter", (PyCFunction) Curve_getIter, METH_NOARGS,
"() - returns an iterator for the curves that make up the Curve"},
{"iterNext", (PyCFunction) Curve_iterNext, METH_NOARGS,
"() - returns the next curve or NULL if at end of list "},
#endif
{NULL, NULL, 0, NULL}
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
};
/*****************************************************************************/
/* Python Curve_Type callback function prototypes: */
/*****************************************************************************/
static void CurveDeAlloc (BPy_Curve * msh);
/* static int CurvePrint (BPy_Curve *msh, FILE *fp, int flags); */
static int CurveSetAttr (BPy_Curve * msh, char *name, PyObject * v);
static PyObject *CurveGetAttr (BPy_Curve * msh, char *name);
static PyObject *CurveRepr (BPy_Curve * msh);
PyObject *Curve_CreatePyObject (struct Curve *curve);
int Curve_CheckPyObject (PyObject * py_obj);
struct Curve *Curve_FromPyObject (PyObject * py_obj);
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PySequenceMethods Curve_as_sequence = {
(inquiry) Curve_length, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(intargfunc) 0, /* sq_repeat */
(intargfunc) Curve_getNurb, /* sq_item */
(intintargfunc) 0, /* sq_slice */
0, /* sq_ass_item */
0, /* sq_ass_slice */
(objobjproc) 0, /* sq_contains */
0,
0
};
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
/*****************************************************************************/
/* Python Curve_Type structure definition: */
/*****************************************************************************/
PyTypeObject Curve_Type = {
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject_HEAD_INIT (NULL) /* required macro */ 0, /* ob_size */
"Curve", /* tp_name - for printing */
sizeof (BPy_Curve), /* tp_basicsize - for allocation */
0, /* tp_itemsize - for allocation */
/* methods for standard operations */
(destructor) CurveDeAlloc, /* tp_dealloc */
0, /* tp_print */
(getattrfunc) CurveGetAttr, /* tp_getattr */
(setattrfunc) CurveSetAttr, /* tp_setattr */
0, /* tp_compare */
(reprfunc) CurveRepr, /* tp_repr */
/* methods for standard classes */
0, /* tp_as_number */
&Curve_as_sequence, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_as_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
/* Flags to define presence of optional/expaned features */
Py_TPFLAGS_HAVE_ITER, /* tp_flags */
0, /* tp_doc - documentation string */
0, /* tp_traverse */
/* delete references to contained objects */
0, /* tp_clear */
0, /* tp_richcompare - rich comparisions */
0, /* tp_weaklistoffset - weak reference enabler */
/* new release 2.2 stuff - Iterators */
(getiterfunc) Curve_getIter, /* tp_iter */
(iternextfunc) Curve_iterNext, /* tp_iternext *//* was Curve_iterNext */
/* Attribute descriptor and subclassing stuff */
BPy_Curve_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset; */
0, /* tp_base; */
0, /* tp_dict; */
0, /* tp_descr_get; */
0, /* tp_descr_set; */
0, /* tp_dictoffset; */
0, /* tp_init; */
0, /* tp_alloc; */
0, /* tp_new; */
0, /* tp_free; Low-level free-memory routine */
0, /* tp_is_gc */
0, /* tp_bases; */
0, /* tp_mro; method resolution order */
0, /* tp_defined; */
0, /* tp_weakllst */
0,
0
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
};
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
/*****************************************************************************/
/* Function: M_Curve_New */
/* Python equivalent: Blender.Curve.New */
/*****************************************************************************/
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *M_Curve_New (PyObject * self, PyObject * args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
char buf[24];
char *name = NULL;
BPy_Curve *pycurve; /* for Curve Data object wrapper in Python */
Curve *blcurve = 0; /* for actual Curve Data we create in Blender */
if(!PyArg_ParseTuple (args, "|s", &name))
return (EXPP_ReturnPyObjError
(PyExc_AttributeError,
"expected string argument or no argument"));
blcurve = add_curve (OB_CURVE); /* first create the Curve Data in Blender */
if(blcurve == NULL) /* bail out if add_curve() failed */
return (EXPP_ReturnPyObjError
(PyExc_RuntimeError,
"couldn't create Curve Data in Blender"));
/* return user count to zero because add_curve() inc'd it */
blcurve->id.us = 0;
/* create python wrapper obj */
pycurve = (BPy_Curve *) PyObject_NEW (BPy_Curve, &Curve_Type);
if(pycurve == NULL)
return (EXPP_ReturnPyObjError
(PyExc_MemoryError,
"couldn't create Curve Data object"));
pycurve->curve = blcurve; /* link Python curve wrapper to Blender Curve */
if(name) {
PyOS_snprintf (buf, sizeof (buf), "%s", name);
rename_id (&blcurve->id, buf);
}
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
return (PyObject *) pycurve;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
/*****************************************************************************/
* Module Curve updated: Jacques Guignot (guignot) sent updated files for his Curve module. * Module Armature (and its submodule Bone) added: Jordi Rovira i Bonet (bandoler) contributed both modules, which are NEW additions to Blender Python, not available in Blender 2.27. * Added function to NMesh.c: Jordi again. He added the function NMesh_getVertexInfluence().
2003-05-29 04:00:35 +00:00
/* Function: M_Curve_Get */
/* Python equivalent: Blender.Curve.Get */
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
/*****************************************************************************/
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *M_Curve_Get (PyObject * self, PyObject * args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
char *name = NULL;
Curve *curv_iter;
BPy_Curve *wanted_curv;
if(!PyArg_ParseTuple (args, "|s", &name)) /* expects nothing or a string */
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected string argument"));
if(name) { /*a name has been given */
/* Use the name to search for the curve requested */
wanted_curv = NULL;
curv_iter = G.main->curve.first;
while((curv_iter) && (wanted_curv == NULL)) {
if(strcmp (name, curv_iter->id.name + 2) == 0) {
wanted_curv =
(BPy_Curve *) PyObject_NEW (BPy_Curve,
&Curve_Type);
if(wanted_curv)
wanted_curv->curve = curv_iter;
}
curv_iter = curv_iter->id.next;
}
if(wanted_curv == NULL) { /* Requested curve doesn't exist */
char error_msg[64];
PyOS_snprintf (error_msg, sizeof (error_msg),
"Curve \"%s\" not found", name);
return (EXPP_ReturnPyObjError
(PyExc_NameError, error_msg));
}
return (PyObject *) wanted_curv;
} /* end of if(name) */
else {
/* no name has been given; return a list of all curves by name. */
PyObject *curvlist;
curv_iter = G.main->curve.first;
curvlist = PyList_New (0);
if(curvlist == NULL)
return (EXPP_ReturnPyObjError (PyExc_MemoryError,
"couldn't create PyList"));
while(curv_iter) {
BPy_Curve *found_cur =
(BPy_Curve *) PyObject_NEW (BPy_Curve,
&Curve_Type);
found_cur->curve = curv_iter;
PyList_Append (curvlist, (PyObject *) found_cur);
curv_iter = curv_iter->id.next;
}
return (curvlist);
} /* end of else */
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
/*****************************************************************************/
- More renaming all around to follow our conventions - Implemented partially Blender.Sys - Worked on issues related to sys, path - Took away most "debug" printfs
2003-06-28 07:38:21 +00:00
/* Function: Curve_Init */
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
/*****************************************************************************/
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *Curve_Init (void)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *submodule;
* Fix compilation errors on Windows hopefully. Implemented the suggestion done by Aphex - thanks. * Added the doc strings to the Object module. * Added more functionality to the Object module.
2003-06-02 20:15:50 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
Curve_Type.ob_type = &PyType_Type;
* Fix compilation errors on Windows hopefully. Implemented the suggestion done by Aphex - thanks. * Added the doc strings to the Object module. * Added more functionality to the Object module.
2003-06-02 20:15:50 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
submodule =
Py_InitModule3 ("Blender.Curve", M_Curve_methods, M_Curve_doc);
return (submodule);
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
/*****************************************************************************/
some cleanup; naming conventions
2003-06-27 07:35:55 +00:00
/* Python BPy_Curve methods: */
* Module Curve updated: Jacques Guignot (guignot) sent updated files for his Curve module. * Module Armature (and its submodule Bone) added: Jordi Rovira i Bonet (bandoler) contributed both modules, which are NEW additions to Blender Python, not available in Blender 2.27. * Added function to NMesh.c: Jordi again. He added the function NMesh_getVertexInfluence().
2003-05-29 04:00:35 +00:00
/* gives access to */
/* name, pathlen totcol flag bevresol */
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
/* resolu resolv width ext1 ext2 */
* Module Curve updated: Jacques Guignot (guignot) sent updated files for his Curve module. * Module Armature (and its submodule Bone) added: Jordi Rovira i Bonet (bandoler) contributed both modules, which are NEW additions to Blender Python, not available in Blender 2.27. * Added function to NMesh.c: Jordi again. He added the function NMesh_getVertexInfluence().
2003-05-29 04:00:35 +00:00
/* controlpoint loc rot size */
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
/* numpts */
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
/*****************************************************************************/
* Module Curve updated: Jacques Guignot (guignot) sent updated files for his Curve module. * Module Armature (and its submodule Bone) added: Jordi Rovira i Bonet (bandoler) contributed both modules, which are NEW additions to Blender Python, not available in Blender 2.27. * Added function to NMesh.c: Jordi again. He added the function NMesh_getVertexInfluence().
2003-05-29 04:00:35 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_getName (BPy_Curve * self)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *attr = PyString_FromString (self->curve->id.name + 2);
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(attr)
return attr;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
"couldn't get Curve.name attribute"));
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_setName (BPy_Curve * self, PyObject * args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
char *name;
char buf[50];
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(!PyArg_ParseTuple (args, "s", &(name)))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected string argument"));
PyOS_snprintf (buf, sizeof (buf), "%s", name);
rename_id (&self->curve->id, buf); /* proper way in Blender */
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
Py_INCREF (Py_None);
return Py_None;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_getPathLen (BPy_Curve * self)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *attr = PyInt_FromLong ((long) self->curve->pathlen);
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(attr)
return attr;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
"couldn't get Curve.pathlen attribute"));
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_setPathLen (BPy_Curve * self, PyObject * args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(!PyArg_ParseTuple (args, "i", &(self->curve->pathlen)))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected int argument"));
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
Py_INCREF (Py_None);
return Py_None;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_getTotcol (BPy_Curve * self)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *attr = PyInt_FromLong ((long) self->curve->totcol);
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(attr)
return attr;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
"couldn't get Curve.totcol attribute"));
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_setTotcol (BPy_Curve * self, PyObject * args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(!PyArg_ParseTuple (args, "i", &(self->curve->totcol)))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected int argument"));
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
Py_INCREF (Py_None);
return Py_None;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_getMode (BPy_Curve * self)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *attr = PyInt_FromLong ((long) self->curve->flag);
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(attr)
return attr;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
"couldn't get Curve.flag attribute"));
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_setMode (BPy_Curve * self, PyObject * args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(!PyArg_ParseTuple (args, "i", &(self->curve->flag)))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected int argument"));
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
Py_INCREF (Py_None);
return Py_None;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_getBevresol (BPy_Curve * self)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *attr = PyInt_FromLong ((long) self->curve->bevresol);
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(attr)
return attr;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
"couldn't get Curve.bevresol attribute"));
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_setBevresol (BPy_Curve * self, PyObject * args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(!PyArg_ParseTuple (args, "i", &(self->curve->bevresol)))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected int argument"));
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
Py_INCREF (Py_None);
return Py_None;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_getResolu (BPy_Curve * self)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *attr = PyInt_FromLong ((long) self->curve->resolu);
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(attr)
return attr;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
"couldn't get Curve.resolu attribute"));
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_setResolu (BPy_Curve * self, PyObject * args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(!PyArg_ParseTuple (args, "i", &(self->curve->resolu)))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected int argument"));
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
Py_INCREF (Py_None);
return Py_None;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_getResolv (BPy_Curve * self)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *attr = PyInt_FromLong ((long) self->curve->resolv);
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(attr)
return attr;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
"couldn't get Curve.resolv attribute"));
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_setResolv (BPy_Curve * self, PyObject * args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(!PyArg_ParseTuple (args, "i", &(self->curve->resolv)))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected int argument"));
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
Py_INCREF (Py_None);
return Py_None;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_getWidth (BPy_Curve * self)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *attr = PyFloat_FromDouble ((double) self->curve->width);
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(attr)
return attr;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
"couldn't get Curve.width attribute"));
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_setWidth (BPy_Curve * self, PyObject * args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(!PyArg_ParseTuple (args, "f", &(self->curve->width)))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected float argument"));
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
Py_INCREF (Py_None);
return Py_None;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_getExt1 (BPy_Curve * self)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *attr = PyFloat_FromDouble ((double) self->curve->ext1);
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(attr)
return attr;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
"couldn't get Curve.ext1 attribute"));
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_setExt1 (BPy_Curve * self, PyObject * args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(!PyArg_ParseTuple (args, "f", &(self->curve->ext1)))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected float argument"));
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
Py_INCREF (Py_None);
return Py_None;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_getExt2 (BPy_Curve * self)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *attr = PyFloat_FromDouble ((double) self->curve->ext2);
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(attr)
return attr;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
"couldn't get Curve.ext2 attribute"));
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_setExt2 (BPy_Curve * self, PyObject * args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(!PyArg_ParseTuple (args, "f", &(self->curve->ext2)))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected float argument"));
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
Py_INCREF (Py_None);
return Py_None;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
change the values of the functions get/set size/loc/rot to lists. added the attributes loc, rot, size changed the parameters of getControlPoint to int int list cosmetic changes in names
2003-07-09 21:18:34 +00:00
/*
some cleanup; naming conventions
2003-06-27 07:35:55 +00:00
static PyObject *Curve_setControlPoint(BPy_Curve *self, PyObject *args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
Nurb*ptrnurb = self->curve->nurb.first;
int numcourbe,numpoint,i,j;
float x,y,z,w;
float bez[9];
* Module Curve updated: Jacques Guignot (guignot) sent updated files for his Curve module. * Module Armature (and its submodule Bone) added: Jordi Rovira i Bonet (bandoler) contributed both modules, which are NEW additions to Blender Python, not available in Blender 2.27. * Added function to NMesh.c: Jordi again. He added the function NMesh_getVertexInfluence().
2003-05-29 04:00:35 +00:00
if (!ptrnurb){ Py_INCREF(Py_None);return Py_None;}
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
if (ptrnurb->bp)
if (!PyArg_ParseTuple(args, "iiffff", &numcourbe,&numpoint,&x,&y,&z,&w))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
several bug fixes
2003-06-21 20:44:44 +00:00
"expected int int float float float float arguments"));
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
if (ptrnurb->bezt)
if (!PyArg_ParseTuple(args, "iifffffffff", &numcourbe,&numpoint,
several bug fixes
2003-06-21 20:44:44 +00:00
bez,bez+1,bez+2,bez+3,bez+4,bez+5,bez+6,bez+7,bez+8))
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
several bug fixes
2003-06-21 20:44:44 +00:00
"expected int int float float float float float float "
"float float float arguments"));
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
for(i = 0;i< numcourbe;i++)
ptrnurb=ptrnurb->next;
if (ptrnurb->bp)
{
ptrnurb->bp[numpoint].vec[0] = x;
ptrnurb->bp[numpoint].vec[1] = y;
ptrnurb->bp[numpoint].vec[2] = z;
ptrnurb->bp[numpoint].vec[3] = w;
}
if (ptrnurb->bezt)
{
for(i = 0;i<3;i++)
several bug fixes
2003-06-21 20:44:44 +00:00
for(j = 0;j<3;j++)
ptrnurb->bezt[numpoint].vec[i][j] = bez[i*3+j];
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
several bug fixes
2003-06-21 20:44:44 +00:00
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
Py_INCREF(Py_None);
return Py_None;
}
change the values of the functions get/set size/loc/rot to lists. added the attributes loc, rot, size changed the parameters of getControlPoint to int int list cosmetic changes in names
2003-07-09 21:18:34 +00:00
*/
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
/*
* Curve_setControlPoint
* this function sets an EXISTING control point.
* it does NOT add a new one.
*/
change the values of the functions get/set size/loc/rot to lists. added the attributes loc, rot, size changed the parameters of getControlPoint to int int list cosmetic changes in names
2003-07-09 21:18:34 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_setControlPoint (BPy_Curve * self, PyObject * args)
{
PyObject *listargs = 0;
Nurb *ptrnurb = self->curve->nurb.first;
int numcourbe, numpoint, i, j;
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(!ptrnurb) {
Py_INCREF (Py_None);
return Py_None;
}
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(ptrnurb->bp)
if(!PyArg_ParseTuple
(args, "iiO", &numcourbe, &numpoint, &listargs))
return (EXPP_ReturnPyObjError
(PyExc_AttributeError,
"expected int int list arguments"));
if(ptrnurb->bezt)
if(!PyArg_ParseTuple
(args, "iiO", &numcourbe, &numpoint, &listargs))
return (EXPP_ReturnPyObjError
(PyExc_AttributeError,
"expected int int list arguments"));
for(i = 0; i < numcourbe; i++)
ptrnurb = ptrnurb->next;
/* fixme: case where ->bp && ->bezt are both NULL is not handled */
if(ptrnurb->bp)
for(i = 0; i < 4; i++)
ptrnurb->bp[numpoint].vec[i] =
PyFloat_AsDouble (PyList_GetItem
(listargs, i));
if(ptrnurb->bezt)
for(i = 0; i < 3; i++)
for(j = 0; j < 3; j++)
ptrnurb->bezt[numpoint].vec[i][j] =
PyFloat_AsDouble (PyList_GetItem
(listargs,
i * 3 + j));
Py_INCREF (Py_None);
return Py_None;
change the values of the functions get/set size/loc/rot to lists. added the attributes loc, rot, size changed the parameters of getControlPoint to int int list cosmetic changes in names
2003-07-09 21:18:34 +00:00
}
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_getControlPoint (BPy_Curve * self, PyObject * args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *liste = PyList_New (0); /* return values */
Nurb *ptrnurb;
int i, j;
/* input args: requested curve and point number on curve */
int numcourbe, numpoint;
if(!PyArg_ParseTuple (args, "ii", &numcourbe, &numpoint))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected int int arguments"));
if((numcourbe < 0) || (numpoint < 0))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
" arguments must be non-negative"));
/* if no nurbs in this curve obj */
if(!self->curve->nurb.first)
return liste;
/* walk the list of nurbs to find requested numcourbe */
ptrnurb = self->curve->nurb.first;
for(i = 0; i < numcourbe; i++) {
ptrnurb = ptrnurb->next;
if(!ptrnurb) /* if zero, we ran just ran out of curves */
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"curve index out of range"));
}
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
/* check numpoint param against pntsu */
if(numpoint >= ptrnurb->pntsu)
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"point index out of range"));
if(ptrnurb->bp) { /* if we are a nurb curve, you get 4 values */
for(i = 0; i < 4; i++)
PyList_Append (liste,
PyFloat_FromDouble (ptrnurb->
bp[numpoint].
vec[i]));
}
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(ptrnurb->bezt) { /* if we are a bezier, you get 9 values */
for(i = 0; i < 3; i++)
for(j = 0; j < 3; j++)
PyList_Append (liste,
PyFloat_FromDouble (ptrnurb->
bezt
[numpoint].
vec[i][j]));
}
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
return liste;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_getLoc (BPy_Curve * self)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
int i;
PyObject *liste = PyList_New (3);
for(i = 0; i < 3; i++)
PyList_SetItem (liste, i,
PyFloat_FromDouble (self->curve->loc[i]));
return liste;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_setLoc (BPy_Curve * self, PyObject * args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *listargs = 0;
int i;
if(!PyArg_ParseTuple (args, "O", &listargs))
return EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected list argument");
if(!PyList_Check (listargs))
return (EXPP_ReturnPyObjError
(PyExc_TypeError, "expected a list"));
for(i = 0; i < 3; i++) {
PyObject *xx = PyList_GetItem (listargs, i);
self->curve->loc[i] = PyFloat_AsDouble (xx);
}
Py_INCREF (Py_None);
return Py_None;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_getRot (BPy_Curve * self)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
int i;
PyObject *liste = PyList_New (3);
for(i = 0; i < 3; i++)
PyList_SetItem (liste, i,
PyFloat_FromDouble (self->curve->rot[i]));
return liste;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_setRot (BPy_Curve * self, PyObject * args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *listargs = 0;
int i;
if(!PyArg_ParseTuple (args, "O", &listargs))
return EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected list argument");
if(!PyList_Check (listargs))
return (EXPP_ReturnPyObjError
(PyExc_TypeError, "expected a list"));
for(i = 0; i < 3; i++) {
PyObject *xx = PyList_GetItem (listargs, i);
self->curve->rot[i] = PyFloat_AsDouble (xx);
}
Py_INCREF (Py_None);
return Py_None;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_getSize (BPy_Curve * self)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
int i;
PyObject *liste = PyList_New (3);
for(i = 0; i < 3; i++)
PyList_SetItem (liste, i,
PyFloat_FromDouble (self->curve->size[i]));
return liste;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_setSize (BPy_Curve * self, PyObject * args)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *listargs = 0;
int i;
if(!PyArg_ParseTuple (args, "O", &listargs))
return EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected list argument");
if(!PyList_Check (listargs))
return (EXPP_ReturnPyObjError
(PyExc_TypeError, "expected a list"));
for(i = 0; i < 3; i++) {
PyObject *xx = PyList_GetItem (listargs, i);
self->curve->size[i] = PyFloat_AsDouble (xx);
}
Py_INCREF (Py_None);
return Py_None;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
/*
* Count the number of splines in a Curve Object
* int getNumCurves()
*/
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_getNumCurves (BPy_Curve * self)
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
Nurb *ptrnurb;
PyObject *ret_val;
int num_curves = 0; /* start with no splines */
/* get curve */
ptrnurb = self->curve->nurb.first;
if(ptrnurb) { /* we have some nurbs in this curve */
while(1) {
++num_curves;
ptrnurb = ptrnurb->next;
if(!ptrnurb) /* no more curves */
break;
}
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
ret_val = PyInt_FromLong ((long) num_curves);
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(ret_val)
return ret_val;
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
/* oops! */
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
"couldn't get number of curves"));
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
}
/*
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
* count the number of points in a given spline
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
* int getNumPoints( curve_num=0 )
*
*/
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_getNumPoints (BPy_Curve * self, PyObject * args)
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
Nurb *ptrnurb;
PyObject *ret_val;
int curve_num = 0; /* default spline number */
int i;
/* parse input arg */
if(!PyArg_ParseTuple (args, "|i", &curve_num))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected int argument"));
/* check arg - must be non-negative */
if(curve_num < 0)
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"argument must be non-negative"));
/* walk the list of curves looking for our curve */
ptrnurb = self->curve->nurb.first;
if(!ptrnurb) { /* no splines in this Curve */
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"no splines in this Curve"));
}
for(i = 0; i < curve_num; i++) {
ptrnurb = ptrnurb->next;
if(!ptrnurb) /* if zero, we ran just ran out of curves */
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"curve index out of range"));
}
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
/* pntsu is the number of points in curve */
ret_val = PyInt_FromLong ((long) ptrnurb->pntsu);
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(ret_val)
return ret_val;
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
/* oops! */
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
"couldn't get number of points for curve"));
}
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
/*
* Test whether a given spline of a Curve is a nurb
* as opposed to a bezier
* int isNurb( curve_num=0 )
*/
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_isNurb (BPy_Curve * self, PyObject * args)
{
int curve_num = 0; /* default value */
int is_nurb;
Nurb *ptrnurb;
PyObject *ret_val;
int i;
/* parse and check input args */
if(!PyArg_ParseTuple (args, "|i", &curve_num)) {
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected int argument"));
}
if(curve_num < 0) {
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"curve number must be non-negative"));
}
ptrnurb = self->curve->nurb.first;
if(!ptrnurb) /* no splines in this curve */
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"no splines in this Curve"));
for(i = 0; i < curve_num; i++) {
ptrnurb = ptrnurb->next;
if(!ptrnurb) /* if zero, we ran just ran out of curves */
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"curve index out of range"));
}
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
/* right now, there are only two curve types, nurb and bezier. */
is_nurb = ptrnurb->bp ? 1 : 0;
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
ret_val = PyInt_FromLong ((long) is_nurb);
if(ret_val)
return ret_val;
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
/* oops */
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
"couldn't get curve type"));
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
/*
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
* Curve_appendPoint( numcurve, new_point )
* append a new point to indicated spline
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
*/
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *Curve_appendPoint (BPy_Curve * self, PyObject * args)
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
int i;
int nurb_num; /* index of curve we append to */
PyObject* coord_args; /* coords for new point */
Nurb* nurb = self->curve->nurb.first; /* first nurb in Curve */
// fixme - need to malloc new Nurb
if( ! nurb )
return( EXPP_ReturnPyObjError
( PyExc_AttributeError,
"no nurbs in this Curve"));
if( ! PyArg_ParseTuple( args,"iO", &nurb_num, &coord_args ))
return( EXPP_ReturnPyObjError
(PyExc_AttributeError,
"expected int, coords as arguments"));
/*
chase down the list of Nurbs looking for our curve.
*/
for( i = 0; i < nurb_num; i++){
nurb = nurb->next;
if( ! nurb ) /* we ran off end of list */
return( EXPP_ReturnPyObjError
( PyExc_AttributeError,
"curve index out of range"));
}
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
return CurNurb_appendPointToNurb( nurb, coord_args );
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
}
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
/*
* Curve_update( )
* method to update display list for a Curve.
* used. after messing with control points
*/
static PyObject *Curve_update( BPy_Curve *self )
{
update_displists( (void*) self->curve );
Py_INCREF (Py_None);
return Py_None;
}
/*
* Curve_getMaterials
*
*/
static PyObject *Curve_getMaterials (BPy_Curve * self)
{
return (EXPP_PyList_fromMaterialList (self->curve->mat,
self->curve->totcol,
1 ) );
}
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
/*
* Curve_getIter
*
* create an iterator for our Curve.
* this iterator returns the Nurbs for this Curve.
* the iter_pointer always points to the next available item or null
*/
static PyObject *Curve_getIter (BPy_Curve * self)
{
self->iter_pointer = self->curve->nurb.first;
Py_INCREF( self );
return (PyObject*) self;
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
}
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
/*
* Curve_iterNext
* get the next item.
* iter_pointer always points to the next available element
* or NULL if at the end of the list.
*/
static PyObject *Curve_iterNext (BPy_Curve * self)
{
PyObject *po; /* return value */
Nurb *pnurb;
if(self->iter_pointer) {
pnurb = self->iter_pointer;
self->iter_pointer = pnurb->next; /* advance iterator */
po = CurNurb_CreatePyObject (pnurb); /* make a bpy_nurb */
return (PyObject *) po;
}
/* if iter_pointer was null, we are at end */
return (EXPP_ReturnPyObjError
(PyExc_StopIteration, "iterator at end"));
}
/* tp_sequence methods */
/*
* Curve_length
* returns the number of curves in a Curve
* this is a tp_as_sequence method, not a regular instance method.
*/
static int Curve_length (PyInstanceObject * inst)
{
if(Curve_CheckPyObject ((PyObject *) inst))
return( (int) PyInt_AsLong
(Curve_getNumCurves ((BPy_Curve *) inst)));
return EXPP_ReturnIntError (PyExc_RuntimeError,
"arg is not a BPy_Curve");
}
/*
* Curve_getNurb
* returns the Nth nurb in a Curve.
* this is one of the tp_as_sequence methods, hence the int N argument.
* it is called via the [] operator, not as a usual instance method.
*/
PyObject *Curve_getNurb (BPy_Curve * self, int n)
{
PyObject *pyo;
Nurb *pNurb;
int i;
/* bail if index < 0 */
if(n < 0)
return (EXPP_ReturnPyObjError (PyExc_IndexError,
"index less than 0"));
/* bail if no Nurbs in Curve */
if(self->curve->nurb.first == 0)
return (EXPP_ReturnPyObjError (PyExc_IndexError,
"no Nurbs in this Curve"));
/* set pointer to nth Nurb */
for(pNurb = self->curve->nurb.first, i = 0;
pNurb != 0 && i < n; pNurb = pNurb->next, ++i)
/**/;
if(!pNurb) /* we came to the end of the list */
return (EXPP_ReturnPyObjError (PyExc_IndexError,
"index out of range"));
pyo = CurNurb_CreatePyObject (pNurb); /* make a bpy_curnurb */
return (PyObject *) pyo;
}
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
/*****************************************************************************/
/* Function: CurveDeAlloc */
some cleanup; naming conventions
2003-06-27 07:35:55 +00:00
/* Description: This is a callback function for the BPy_Curve type. It is */
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
/* the destructor function. */
/*****************************************************************************/
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static void CurveDeAlloc (BPy_Curve * self)
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject_DEL (self);
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
/*****************************************************************************/
/* Function: CurveGetAttr */
some cleanup; naming conventions
2003-06-27 07:35:55 +00:00
/* Description: This is a callback function for the BPy_Curve type. It is */
/* the function that accesses BPy_Curve "member variables" and */
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
/* methods. */
/*****************************************************************************/
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *CurveGetAttr (BPy_Curve * self, char *name)
{ /* getattr */
PyObject *attr = Py_None;
if(strcmp (name, "name") == 0)
attr = PyString_FromString (self->curve->id.name + 2);
if(strcmp (name, "pathlen") == 0)
attr = PyInt_FromLong (self->curve->pathlen);
if(strcmp (name, "totcol") == 0)
attr = PyInt_FromLong (self->curve->totcol);
if(strcmp (name, "flag") == 0)
attr = PyInt_FromLong (self->curve->flag);
if(strcmp (name, "bevresol") == 0)
attr = PyInt_FromLong (self->curve->bevresol);
if(strcmp (name, "resolu") == 0)
attr = PyInt_FromLong (self->curve->resolu);
if(strcmp (name, "resolv") == 0)
attr = PyInt_FromLong (self->curve->resolv);
if(strcmp (name, "width") == 0)
attr = PyFloat_FromDouble (self->curve->width);
if(strcmp (name, "ext1") == 0)
attr = PyFloat_FromDouble (self->curve->ext1);
if(strcmp (name, "ext2") == 0)
attr = PyFloat_FromDouble (self->curve->ext2);
if(strcmp (name, "loc") == 0)
return Curve_getLoc (self);
if(strcmp (name, "rot") == 0)
return Curve_getRot (self);
if(strcmp (name, "size") == 0)
return Curve_getSize (self);
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
#if 0
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(strcmp (name, "numpts") == 0)
return Curve_getNumPoints (self);
Modification of the GetControlPoint function by Stephen, who is now responsible for this module slight bug fixes (Steph.)
2003-09-02 20:11:11 +00:00
#endif
* Module Curve updated: Jacques Guignot (guignot) sent updated files for his Curve module. * Module Armature (and its submodule Bone) added: Jordi Rovira i Bonet (bandoler) contributed both modules, which are NEW additions to Blender Python, not available in Blender 2.27. * Added function to NMesh.c: Jordi again. He added the function NMesh_getVertexInfluence().
2003-05-29 04:00:35 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(!attr)
return (EXPP_ReturnPyObjError (PyExc_MemoryError,
"couldn't create PyObject"));
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(attr != Py_None)
return attr; /* member attribute found, return it */
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
/* not an attribute, search the methods table */
return Py_FindMethod (BPy_Curve_methods, (PyObject *) self, name);
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
/*****************************************************************************/
/* Function: CurveSetAttr */
some cleanup; naming conventions
2003-06-27 07:35:55 +00:00
/* Description: This is a callback function for the BPy_Curve type. It is the */
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
/* function that sets Curve Data attributes (member variables). */
/*****************************************************************************/
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static int CurveSetAttr (BPy_Curve * self, char *name, PyObject * value)
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
PyObject *valtuple;
PyObject *error = NULL;
valtuple = Py_BuildValue ("(O)", value);
/* resolu resolv width ext1 ext2 */
if(!valtuple)
return EXPP_ReturnIntError (PyExc_MemoryError,
"CurveSetAttr: couldn't create PyTuple");
if(strcmp (name, "name") == 0)
error = Curve_setName (self, valtuple);
else if(strcmp (name, "pathlen") == 0)
error = Curve_setPathLen (self, valtuple);
else if(strcmp (name, "resolu") == 0)
error = Curve_setResolu (self, valtuple);
else if(strcmp (name, "resolv") == 0)
error = Curve_setResolv (self, valtuple);
else if(strcmp (name, "width") == 0)
error = Curve_setWidth (self, valtuple);
else if(strcmp (name, "ext1") == 0)
error = Curve_setExt1 (self, valtuple);
else if(strcmp (name, "ext2") == 0)
error = Curve_setExt2 (self, valtuple);
else if(strcmp (name, "loc") == 0)
error = Curve_setLoc (self, valtuple);
else if(strcmp (name, "rot") == 0)
error = Curve_setRot (self, valtuple);
else if(strcmp (name, "size") == 0)
error = Curve_setSize (self, valtuple);
else { /* Error */
Py_DECREF (valtuple);
if((strcmp (name, "Types") == 0)
|| (strcmp (name, "Modes") == 0))
return (EXPP_ReturnIntError
(PyExc_AttributeError,
"constant dictionary -- cannot be changed"));
else
return (EXPP_ReturnIntError
(PyExc_KeyError, "attribute not found"));
}
* Module Curve updated: Jacques Guignot (guignot) sent updated files for his Curve module. * Module Armature (and its submodule Bone) added: Jordi Rovira i Bonet (bandoler) contributed both modules, which are NEW additions to Blender Python, not available in Blender 2.27. * Added function to NMesh.c: Jordi again. He added the function NMesh_getVertexInfluence().
2003-05-29 04:00:35 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
Py_DECREF (valtuple);
* Module Curve updated: Jacques Guignot (guignot) sent updated files for his Curve module. * Module Armature (and its submodule Bone) added: Jordi Rovira i Bonet (bandoler) contributed both modules, which are NEW additions to Blender Python, not available in Blender 2.27. * Added function to NMesh.c: Jordi again. He added the function NMesh_getVertexInfluence().
2003-05-29 04:00:35 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(error != Py_None)
return -1;
Py_DECREF (Py_None);
return 0;
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
/*****************************************************************************/
/* Function: CurveRepr */
some cleanup; naming conventions
2003-06-27 07:35:55 +00:00
/* Description: This is a callback function for the BPy_Curve type. It */
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
/* builds a meaninful string to represent curve objects. */
/*****************************************************************************/
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
static PyObject *CurveRepr (BPy_Curve * self)
{ /* used by 'repr' */
General housekeeping and cleanup. Move static declarations and data definitions from .h files into corresponding .c files. Blame zr for this since he's the one who pointed out that our bpy headers were a mish-mash of stuff that belonged in the .c files! In a nutshell, the headers should contain the declarations necessary to use a module or class. The implementation files ( .c in this case ) should contain statements that allocate storage ( definitions in the C sense ) and executable code. When used at file scope, the keyword 'static' means "don't tell anyone else about this". Since headers describe a public interface, static declarations and definitions belong in the implementation files. The net result of all this is that after stuff has moved out into the .c files, the .h files are empty or mostly empty. I didn't delete them since there seem to be some public declarations and because I did not want to cause too much disruption at one time. Time enough for that later!
2004-03-29 08:16:18 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
return PyString_FromFormat ("[Curve \"%s\"]",
self->curve->id.name + 2);
* Added Blender.Curve submodule, written by Jacques Guignot (guignot): Jacques contributed a new module to exppython, one that isn't available in the current 2.27 API. Welcome, guignot : ).
2003-05-17 07:08:08 +00:00
}
Guignot implemented 3 functions needed by the Object Module
2003-05-20 03:53:30 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
/*
* Curve_CreatePyObject
* constructor to build a py object from blender data
*/
PyObject *Curve_CreatePyObject (struct Curve * curve)
Guignot implemented 3 functions needed by the Object Module
2003-05-20 03:53:30 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
BPy_Curve *blen_object;
Guignot implemented 3 functions needed by the Object Module
2003-05-20 03:53:30 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
blen_object = (BPy_Curve *) PyObject_NEW (BPy_Curve, &Curve_Type);
Guignot implemented 3 functions needed by the Object Module
2003-05-20 03:53:30 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
if(blen_object == NULL) {
return (NULL);
}
blen_object->curve = curve;
return ((PyObject *) blen_object);
Guignot implemented 3 functions needed by the Object Module
2003-05-20 03:53:30 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
int Curve_CheckPyObject (PyObject * py_obj)
Guignot implemented 3 functions needed by the Object Module
2003-05-20 03:53:30 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
return (py_obj->ob_type == &Curve_Type);
Guignot implemented 3 functions needed by the Object Module
2003-05-20 03:53:30 +00:00
}
* Module Curve updated: Jacques Guignot (guignot) sent updated files for his Curve module. * Module Armature (and its submodule Bone) added: Jordi Rovira i Bonet (bandoler) contributed both modules, which are NEW additions to Blender Python, not available in Blender 2.27. * Added function to NMesh.c: Jordi again. He added the function NMesh_getVertexInfluence().
2003-05-29 04:00:35 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
struct Curve *Curve_FromPyObject (PyObject * py_obj)
Guignot implemented 3 functions needed by the Object Module
2003-05-20 03:53:30 +00:00
{
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
BPy_Curve *blen_obj;
blen_obj = (BPy_Curve *) py_obj;
return (blen_obj->curve);
}
Guignot implemented 3 functions needed by the Object Module
2003-05-20 03:53:30 +00:00
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
/*
* walk across all objects looking for curves
* so we can update their ob's disp list
*/
void update_displists( void* data )
{
Base *base;
Object *ob;
unsigned int layer;
/* background */
layer = G.scene->lay;
base = G.scene->base.first;
while(base) {
if(base->lay & layer)
{
ob = base->object;
if ELEM(ob->type, OB_CURVE, OB_SURF) {
if(ob != G.obedit) {
if ( ob->data == data ){
makeDispList( ob );
}
}
}
else if(ob->type == OB_FONT) {
Curve *cu= ob->data;
if(cu->textoncurve) {
if( ((Curve *)cu->textoncurve->data)->key ) {
text_to_curve(ob, 0);
makeDispList(ob);
}
}
}
}
if( base->next == 0 && G.scene->set && base == G.scene->base.last)
base= G.scene->set->base.first;
else
base= base->next;
}
Guignot implemented 3 functions needed by the Object Module
2003-05-20 03:53:30 +00:00
}
New Curve method Curve.appendPoint( numcurve, newpoint ) to add points to a Curve. New supporting module CurNurb to provide access to the curves in a Curve and their associated points. Curve module now supports Python iterator and sequence protocols. This allows typical python programming idioms using 'for' statement and the [] operator. # example 1 for curve in a_curve: for point in curve: print point #example 2 curnurb = a_curve[0] curnurb.append( [1,1,1,1] ) Still under construction. Epydoc will follow.
2004-07-21 21:01:15 +00:00
Copy Permalink