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
688cc11302caa8cde5649e6230c66a1c60cd24a2
blender-archive/source/blender/python/api2_2x/Ipocurve.c

1107 lines
34 KiB
C
Raw Normal View History

Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
/*
Patch from GSR that a) fixes a whole bunch of GPL/BL license blocks that were previously missed; and b) greatly increase my ohloh stats!
2008-04-16 22:40:48 +00:00
* $Id$
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
*
Patch from GSR that a) fixes a whole bunch of GPL/BL license blocks that were previously missed; and b) greatly increase my ohloh stats!
2008-04-16 22:40:48 +00:00
* ***** BEGIN GPL LICENSE BLOCK *****
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
*
* 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
Patch from GSR that a) fixes a whole bunch of GPL/BL license blocks that were previously missed; and b) greatly increase my ohloh stats!
2008-04-16 22:40:48 +00:00
* of the License, or (at your option) any later version.
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
*
* 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.
*
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
* Contributor(s): Jacques Guignot, Nathan Letwory, Ken Hughes, Johnny Matthews
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
*
Patch from GSR that a) fixes a whole bunch of GPL/BL license blocks that were previously missed; and b) greatly increase my ohloh stats!
2008-04-16 22:40:48 +00:00
* ***** END GPL LICENSE BLOCK *****
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
*/
Header file clean up and warning fixes - Mostly this cleans up the #includes and header files in the python project. - Warning fixes are mostly casting issues and misc fixes. General warning clean up. - #include Python.h MUST come as the first include to avoid the POSIX redefine warning in the unix makefiles - fno-strict-aliasing flag added to makefile to fix a unavoidable type punning warning in types.c
2005-07-18 03:50:37 +00:00
#include "Ipocurve.h" /*This must come first*/
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
#include "Object.h"
Header file clean up and warning fixes - Mostly this cleans up the #includes and header files in the python project. - Warning fixes are mostly casting issues and misc fixes. General warning clean up. - #include Python.h MUST come as the first include to avoid the POSIX redefine warning in the unix makefiles - fno-strict-aliasing flag added to makefile to fix a unavoidable type punning warning in types.c
2005-07-18 03:50:37 +00:00
#include "BKE_global.h"
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
#include "BKE_main.h"
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
#include "BKE_depsgraph.h"
Header file clean up and warning fixes - Mostly this cleans up the #includes and header files in the python project. - Warning fixes are mostly casting issues and misc fixes. General warning clean up. - #include Python.h MUST come as the first include to avoid the POSIX redefine warning in the unix makefiles - fno-strict-aliasing flag added to makefile to fix a unavoidable type punning warning in types.c
2005-07-18 03:50:37 +00:00
#include "BKE_ipo.h"
Used GET_INT_FROM_POINTER to get rid of many warnings that only occurred with 64bit os's Also use Py_ssize_t which we might need to define for older python's
2008-04-17 21:14:55 +00:00
#include "BKE_utildefines.h"
== Keyframing - Cleanup of API == * Moved all keyframing functions to their own file (keyframing.c) * Merged all the different keyframing options (needed, visual, fast) into a single API call. The direct benefit of this is that it allows them to be used in conjunction with each other. Also, this means that when using the IKEY, autokeying settings for these are respected too. * Implemented 'keyingsets' system (instead of directly calling insertkey on relevant channels), which is easier to maintain and cleaner. A keyingset basically defines all the channels that can be keyframed together. This paves the way for custom keyingsets sometime down the track (and also for quick-insert keyframes for previously used keyingset). Menus for choosing the keying set to use are generated automatically from the definitions.
2008-09-14 04:32:17 +00:00
#include "BIF_keyframing.h"
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
#include "BIF_space.h"
Header file clean up and warning fixes - Mostly this cleans up the #includes and header files in the python project. - Warning fixes are mostly casting issues and misc fixes. General warning clean up. - #include Python.h MUST come as the first include to avoid the POSIX redefine warning in the unix makefiles - fno-strict-aliasing flag added to makefile to fix a unavoidable type punning warning in types.c
2005-07-18 03:50:37 +00:00
#include "BSE_editipo.h"
#include "MEM_guardedalloc.h"
#include "DNA_ipo_types.h"
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
#include "DNA_key_types.h"
Quick PyAPI patch: Now it is possible to clean IPO-curves using the call: icu.clean() There's an optional value to specify the threshold to use for cleaning. This just wraps the internal clean_ipo_curve() function.
2008-10-11 12:17:16 +00:00
#include "DNA_scene_types.h"
Another step in the Big Bpy Cleanup. - move static declarations and data definitions out of headers. the BGL module still need cleaning. - move declarations out of modules.h and into appropriate .h files. modules.h still exists as a container for the few modules that need to #include almost everything. - all files now have a $Id tag and have been formatted by indent there are no changes to executable code. pre-commit versions are tagged with bpy-cleanup-pre-20041007 for the sake of paranoia.
2004-10-07 19:25:40 +00:00
#include "BezTriple.h"
Header file clean up and warning fixes - Mostly this cleans up the #includes and header files in the python project. - Warning fixes are mostly casting issues and misc fixes. General warning clean up. - #include Python.h MUST come as the first include to avoid the POSIX redefine warning in the unix makefiles - fno-strict-aliasing flag added to makefile to fix a unavoidable type punning warning in types.c
2005-07-18 03:50:37 +00:00
#include "gen_utils.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.IpoCurve.__doc__ */
/*****************************************************************************/
char M_IpoCurve_doc[] = "";
char M_IpoCurve_New_doc[] = "";
char M_IpoCurve_Get_doc[] = "";
/*****************************************************************************/
/* Python method structure definition for Blender.IpoCurve module: */
/*****************************************************************************/
struct PyMethodDef M_IpoCurve_methods[] = {
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
{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 C_IpoCurve methods declarations: */
/*****************************************************************************/
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
static PyObject *IpoCurve_getName( C_IpoCurve * self );
static PyObject *IpoCurve_Recalc( C_IpoCurve * self );
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
static PyObject *IpoCurve_append( C_IpoCurve * self, PyObject * value );
static PyObject *IpoCurve_addBezier( C_IpoCurve * self, PyObject * value );
New IPO methods. Ipo.delCurve( curve_name ) deletes named curve from IPO. Ipocurve.delBezier( int ) deletes point at index from Ipocurve. Contributed by Ken Hughes (khughes). Thanks!
2005-04-24 19:03:39 +00:00
static PyObject *IpoCurve_delBezier( C_IpoCurve * self, PyObject * args );
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
static PyObject *IpoCurve_setInterpolation( C_IpoCurve * self,
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
PyObject * value );
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
static PyObject *IpoCurve_getInterpolation( C_IpoCurve * self );
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
static PyObject *IpoCurve_newgetInterp( C_IpoCurve * self );
static int IpoCurve_newsetInterp( C_IpoCurve * self, PyObject * args );
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
static PyObject *IpoCurve_setExtrapolation( C_IpoCurve * self,
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
PyObject * value );
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
static PyObject *IpoCurve_getExtrapolation( C_IpoCurve * self );
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
static PyObject *IpoCurve_newgetExtend( C_IpoCurve * self );
static int IpoCurve_newsetExtend( C_IpoCurve * self, PyObject * args );
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
static PyObject *IpoCurve_getPoints( C_IpoCurve * self );
Quick PyAPI patch: Now it is possible to clean IPO-curves using the call: icu.clean() There's an optional value to specify the threshold to use for cleaning. This just wraps the internal clean_ipo_curve() function.
2008-10-11 12:17:16 +00:00
static PyObject *IpoCurve_clean( C_IpoCurve * self, PyObject *value );
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
static PyObject *IpoCurve_evaluate( C_IpoCurve * self, PyObject * args );
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
static PyObject *IpoCurve_getDriver( C_IpoCurve * self );
static int IpoCurve_setDriver( C_IpoCurve * self, PyObject * args );
static PyObject *IpoCurve_getDriverObject( C_IpoCurve * self);
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
static int IpoCurve_setDriverObject( C_IpoCurve * self, PyObject * args );
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
static PyObject *IpoCurve_getDriverChannel( C_IpoCurve * self);
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
static int IpoCurve_setDriverChannel( C_IpoCurve * self, PyObject * args );
PyAPI driverExpression: added "ipocurve.driver = 2" to set the curve to use driver python expressions. added ipocurve.driverExpression - the string to run.
2006-12-25 10:44:28 +00:00
static PyObject *IpoCurve_getDriverExpression( C_IpoCurve * self);
driverExpression - strcpy on wrong type (my bad) fixed. added .sel bool for Ipo curves.
2007-01-13 04:53:41 +00:00
static PyObject *IpoCurve_getFlag( C_IpoCurve * self, void *type);
static int IpoCurve_setFlag( C_IpoCurve * self, PyObject *value, void *type);
PyAPI driverExpression: added "ipocurve.driver = 2" to set the curve to use driver python expressions. added ipocurve.driverExpression - the string to run.
2006-12-25 10:44:28 +00:00
static int IpoCurve_setDriverExpression( C_IpoCurve * self, PyObject * args );
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
static PyObject *IpoCurve_getCurval( C_IpoCurve * self, PyObject * args );
static int IpoCurve_setCurval( C_IpoCurve * self, PyObject * key,
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
/*****************************************************************************/
/* Python C_IpoCurve methods table: */
/*****************************************************************************/
static PyMethodDef C_IpoCurve_methods[] = {
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
/* name, method, flags, doc */
{"getName", ( PyCFunction ) IpoCurve_getName, METH_NOARGS,
updates to doc strings in code and doc from Ken Hughes. add alias .recalc() for IpoCurve.Recalc() to match api standard.
2005-05-24 15:14:32 +00:00
"() - Return IpoCurve name"},
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
{"Recalc", ( PyCFunction ) IpoCurve_Recalc, METH_NOARGS,
updates to doc strings in code and doc from Ken Hughes. add alias .recalc() for IpoCurve.Recalc() to match api standard.
2005-05-24 15:14:32 +00:00
"() - deprecated method. use recalc() instead"},
{"recalc", ( PyCFunction ) IpoCurve_Recalc, METH_NOARGS,
"() - Recomputes the curve after changes"},
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
{"update", ( PyCFunction ) IpoCurve_Recalc, METH_NOARGS,
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
"() - deprecated method: use recalc method instead."},
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
{"append", ( PyCFunction ) IpoCurve_append, METH_O,
updates to doc strings in code and doc from Ken Hughes. add alias .recalc() for IpoCurve.Recalc() to match api standard.
2005-05-24 15:14:32 +00:00
"(coordlist) - Adds a Bezier point to a curve"},
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
{"addBezier", ( PyCFunction ) IpoCurve_addBezier, METH_O,
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
"() - deprecated method. use append() instead"},
New IPO methods. Ipo.delCurve( curve_name ) deletes named curve from IPO. Ipocurve.delBezier( int ) deletes point at index from Ipocurve. Contributed by Ken Hughes (khughes). Thanks!
2005-04-24 19:03:39 +00:00
{"delBezier", ( PyCFunction ) IpoCurve_delBezier, METH_VARARGS,
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
"() - deprecated method. use \"del icu[index]\" instead"},
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
{"setInterpolation", ( PyCFunction ) IpoCurve_setInterpolation,
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
METH_O, "(str) - Sets the interpolation type of the curve"},
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
{"getInterpolation", ( PyCFunction ) IpoCurve_getInterpolation,
updates to doc strings in code and doc from Ken Hughes. add alias .recalc() for IpoCurve.Recalc() to match api standard.
2005-05-24 15:14:32 +00:00
METH_NOARGS, "() - Gets the interpolation type of the curve"},
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
{"setExtrapolation", ( PyCFunction ) IpoCurve_setExtrapolation,
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
METH_O, "(str) - Sets the extend mode of the curve"},
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
{"getExtrapolation", ( PyCFunction ) IpoCurve_getExtrapolation,
updates to doc strings in code and doc from Ken Hughes. add alias .recalc() for IpoCurve.Recalc() to match api standard.
2005-05-24 15:14:32 +00:00
METH_NOARGS, "() - Gets the extend mode of the curve"},
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
{"getPoints", ( PyCFunction ) IpoCurve_getPoints, METH_NOARGS,
updates to doc strings in code and doc from Ken Hughes. add alias .recalc() for IpoCurve.Recalc() to match api standard.
2005-05-24 15:14:32 +00:00
"() - Returns list of all bezTriples of the curve"},
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
{"evaluate", ( PyCFunction ) IpoCurve_evaluate, METH_VARARGS,
"(float) - Evaluate curve at given time"},
Quick PyAPI patch: Now it is possible to clean IPO-curves using the call: icu.clean() There's an optional value to specify the threshold to use for cleaning. This just wraps the internal clean_ipo_curve() function.
2008-10-11 12:17:16 +00:00
{"clean", ( PyCFunction ) IpoCurve_clean, METH_VARARGS,
"(float) - Clean BezTriples using the given threshold value"},
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
{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 API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
/*
* IpoCurve methods
*/
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
static PyGetSetDef C_IpoCurve_getseters[] = {
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
{"name",
(getter)IpoCurve_getName, (setter)NULL,
"the IpoCurve name",
NULL},
{"bezierPoints",
(getter)IpoCurve_getPoints, (setter)NULL,
"list of all bezTriples of the curve",
NULL},
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
{"driver",
(getter)IpoCurve_getDriver, (setter)IpoCurve_setDriver,
driverExpression - strcpy on wrong type (my bad) fixed. added .sel bool for Ipo curves.
2007-01-13 04:53:41 +00:00
"The status of the driver 1-object, 2-py expression, 0-off",
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
NULL},
{"driverObject",
(getter)IpoCurve_getDriverObject, (setter)IpoCurve_setDriverObject,
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
"The object used to drive the IpoCurve",
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
NULL},
{"driverChannel",
(getter)IpoCurve_getDriverChannel, (setter)IpoCurve_setDriverChannel,
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
"The channel on the driver object used to drive the IpoCurve",
NULL},
PyAPI driverExpression: added "ipocurve.driver = 2" to set the curve to use driver python expressions. added ipocurve.driverExpression - the string to run.
2006-12-25 10:44:28 +00:00
{"driverExpression",
(getter)IpoCurve_getDriverExpression, (setter)IpoCurve_setDriverExpression,
"The python expression on the driver used to drive the IpoCurve",
NULL},
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
{"interpolation",
(getter)IpoCurve_newgetInterp, (setter)IpoCurve_newsetInterp,
"The interpolation mode of the curve",
NULL},
{"extend",
(getter)IpoCurve_newgetExtend, (setter)IpoCurve_newsetExtend,
"The extend mode of the curve",
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
NULL},
driverExpression - strcpy on wrong type (my bad) fixed. added .sel bool for Ipo curves.
2007-01-13 04:53:41 +00:00
{"sel",
(getter)IpoCurve_getFlag, (setter)IpoCurve_setFlag,
"the selection state of the curve",
(void *)IPO_SELECT},
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
{NULL,NULL,NULL,NULL,NULL}
};
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
/*****************************************************************************/
/* Python IpoCurve_Type Mapping Methods table: */
/*****************************************************************************/
static PyMappingMethods IpoCurve_as_mapping = {
( inquiry ) 0, /* mp_length */
( binaryfunc ) IpoCurve_getCurval, /* mp_subscript */
( objobjargproc ) IpoCurve_setCurval, /* mp_ass_subscript */
};
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 IpoCurve_Type callback function prototypes: */
/*****************************************************************************/
added comparison function to many python types so you can do == and =!
2006-10-06 16:48:28 +00:00
static int IpoCurve_compare( C_IpoCurve * a, C_IpoCurve * b );
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
static PyObject *IpoCurve_repr( C_IpoCurve * self );
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 IpoCurve_Type structure definition: */
/*****************************************************************************/
PyTypeObject IpoCurve_Type = {
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
PyObject_HEAD_INIT( NULL ) /* required macro */
0, /* ob_size */
"IpoCurve", /* tp_name */
sizeof( C_IpoCurve ), /* tp_basicsize */
0, /* tp_itemsize */
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
/* methods */
removed unneeded dealloc functions
2007-03-15 01:47:53 +00:00
NULL, /* tp_dealloc */
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
0, /* tp_print */
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
( getattrfunc ) NULL, /* tp_getattr */
( setattrfunc ) NULL, /* tp_setattr */
added comparison function to many python types so you can do == and =!
2006-10-06 16:48:28 +00:00
( cmpfunc ) IpoCurve_compare, /* tp_compare */
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
( reprfunc ) IpoCurve_repr, /* tp_repr */
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
/* Method suites for standard classes */
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
&IpoCurve_as_mapping, /* PyMappingMethods *tp_as_mapping; */
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT, /* long tp_flags; */
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
NULL, /* char *tp_doc; */
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
C_IpoCurve_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
C_IpoCurve_getseters, /* struct PyGetSetDef *tp_getset; */
NULL, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
NULL, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
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
};
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
/*****************************************************************************/
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
/* local utility functions */
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
/*****************************************************************************/
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
/*
* Keys are handled differently than other Ipos, so go through contortions
* to find their names.
*/
static char *get_key_curvename( IpoCurve *ipocurve )
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
{
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
Key *key_iter;
char *empty = "";
/* search for keys with an Ipo */
for( key_iter = G.main->key.first; key_iter; key_iter=key_iter->id.next) {
if( key_iter->ipo ) {
IpoCurve *icu = key_iter->ipo->curve.first;
/* search curves for a match */
while( icu ) {
if( icu == ipocurve ) {
KeyBlock *block = key_iter->block.first;
/* search for matching adrcode */
while( block ) {
if( block->adrcode == ipocurve->adrcode )
return block->name;
block = block->next;
}
}
icu = icu->next;
}
}
}
/* shouldn't get here unless deleted in UI while BPy object alive */
return empty;
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
}
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
/*
* internal bpy func to get Ipo Curve Name, used by Ipo.c and
* KX_BlenderSceneConverter.cpp.
*
* We are returning a pointer to string constants so there are
* no issues with who owns pointers.
*/
char *getIpoCurveName( IpoCurve * icu )
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
{
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
switch ( icu->blocktype ) {
case ID_MA:
return getname_mat_ei( icu->adrcode );
case ID_WO:
return getname_world_ei( icu->adrcode );
case ID_CA:
return getname_cam_ei( icu->adrcode );
case ID_OB:
return getname_ob_ei( icu->adrcode, 1 );
/* solve: what if EffX/Y/Z are wanted? */
case ID_TE:
return getname_tex_ei( icu->adrcode );
case ID_LA:
return getname_la_ei( icu->adrcode );
case ID_PO:
return getname_ac_ei( icu->adrcode );
case ID_CU:
return getname_cu_ei( icu->adrcode );
case ID_KE:
/* return "Key"; */
/* ipo curves have no names... that was only meant for drawing the buttons... (ton) */
return get_key_curvename( icu );
case ID_SEQ:
return getname_seq_ei( icu->adrcode );
case ID_CO:
return getname_co_ei( icu->adrcode );
}
return NULL;
}
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
/*
* delete a bezTriple from a curve
*/
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
static void del_beztriple( IpoCurve *icu, int index )
{
int npoints = icu->totvert - 1;
BezTriple * tmp = icu->bezt;
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
/*
* if delete empties list, then delete it, otherwise copy the remaining
* points to a new list
*/
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
if( !npoints ) {
icu->bezt = NULL;
} else {
icu->bezt =
MEM_mallocN( sizeof( BezTriple ) * npoints, "bezt" );
if( index > 0 )
memmove( icu->bezt, tmp, index * sizeof( BezTriple ) );
if( index < npoints )
memmove( icu->bezt + index, tmp + index + 1,
( npoints - index ) * sizeof( BezTriple ) );
}
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
/* free old list, adjust vertex count */
MEM_freeN( tmp );
icu->totvert--;
/* call calchandles_* instead of testhandles_* */
/* I'm not sure this is a complete solution but since we do not */
/* deal with curve handles right now, it seems ok */
calchandles_ipocurve( icu );
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
}
/*****************************************************************************/
reincorporation in the cvs of modifications which had been lost.
2003-07-21 00:08:30 +00:00
/* Python C_IpoCurve methods: */
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
/*****************************************************************************/
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
static PyObject *IpoCurve_setInterpolation( C_IpoCurve * self,
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
PyObject * value )
reincorporation in the cvs of modifications which had been lost.
2003-07-21 00:08:30 +00:00
{
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
char *interpolationtype = PyString_AsString(value);
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
short id;
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
if( !interpolationtype )
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
return EXPP_ReturnPyObjError( PyExc_TypeError,
"expected string argument" );
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
if( !strcmp( interpolationtype, "Bezier" ) )
id = IPO_BEZ;
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
else if( !strcmp( interpolationtype, "Constant" ) )
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
id = IPO_CONST;
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
else if( !strcmp( interpolationtype, "Linear" ) )
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
id = IPO_LIN;
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
else
return EXPP_ReturnPyObjError( PyExc_TypeError,
"bad interpolation type" );
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
self->ipocurve->ipo = id;
Py_RETURN_NONE;
reincorporation in the cvs of modifications which had been lost.
2003-07-21 00:08:30 +00:00
}
removed unuseful function calls in BezTriple.[ch] general cleaning of Ipocurve.c Ipocurve.h Ipo.h Ipo.c updated doc
2003-08-05 10:19:28 +00:00
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
static PyObject *IpoCurve_getInterpolation( C_IpoCurve * self )
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
{
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
char *str = 0;
IpoCurve *icu = self->ipocurve;
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
switch( icu->ipo ) {
case IPO_BEZ:
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
str = "Bezier";
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
break;
case IPO_CONST:
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
str = "Constant";
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
break;
case IPO_LIN:
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
str = "Linear";
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
break;
default:
return EXPP_ReturnPyObjError( PyExc_TypeError,
"unknown interpolation type" );
}
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
return PyString_FromString( str );
reincorporation in the cvs of modifications which had been lost.
2003-07-21 00:08:30 +00:00
}
removed unuseful function calls in BezTriple.[ch] general cleaning of Ipocurve.c Ipocurve.h Ipo.h Ipo.c updated doc
2003-08-05 10:19:28 +00:00
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
static PyObject * IpoCurve_setExtrapolation( C_IpoCurve * self,
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
PyObject * value )
reincorporation in the cvs of modifications which had been lost.
2003-07-21 00:08:30 +00:00
{
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
char *extrapolationtype = PyString_AsString(value);
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
short id;
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
if( !extrapolationtype )
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
return EXPP_ReturnPyObjError( PyExc_TypeError,
"expected string argument" );
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
if( !strcmp( extrapolationtype, "Constant" ) )
id = 0;
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
else if( !strcmp( extrapolationtype, "Extrapolation" ) )
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
id = 1;
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
else if( !strcmp( extrapolationtype, "Cyclic" ) )
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
id = 2;
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
else if( !strcmp( extrapolationtype, "Cyclic_extrapolation" ) )
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
id = 3;
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
else
return EXPP_ReturnPyObjError( PyExc_TypeError,
"bad interpolation type" );
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
self->ipocurve->extrap = id;
Py_RETURN_NONE;
reincorporation in the cvs of modifications which had been lost.
2003-07-21 00:08:30 +00:00
}
removed unuseful function calls in BezTriple.[ch] general cleaning of Ipocurve.c Ipocurve.h Ipo.h Ipo.c updated doc
2003-08-05 10:19:28 +00:00
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
static PyObject *IpoCurve_getExtrapolation( C_IpoCurve * self )
reincorporation in the cvs of modifications which had been lost.
2003-07-21 00:08:30 +00:00
{
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
char *str;
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
IpoCurve *icu = self->ipocurve;
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
switch( icu->extrap ) {
case 0:
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
str = "Constant";
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
break;
case 1:
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
str = "Extrapolation";
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
break;
case 2:
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
str = "Cyclic";
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
break;
case 3:
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
str = "Cyclic_extrapolation";
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
break;
default:
return EXPP_ReturnPyObjError( PyExc_TypeError,
"bad extrapolation type" );
}
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
return PyString_FromString( str );
reincorporation in the cvs of modifications which had been lost.
2003-07-21 00:08:30 +00:00
}
removed unuseful function calls in BezTriple.[ch] general cleaning of Ipocurve.c Ipocurve.h Ipo.h Ipo.c updated doc
2003-08-05 10:19:28 +00:00
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
/*
* append a new BezTriple to curve
*/
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
static PyObject *IpoCurve_append( C_IpoCurve * self, PyObject * value )
reincorporation in the cvs of modifications which had been lost.
2003-07-21 00:08:30 +00:00
{
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
float x, y;
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
IpoCurve *icu = self->ipocurve;
/* if args is a already a beztriple, tack onto end of list */
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
if( BPy_BezTriple_Check ( value ) ) {
BPy_BezTriple *bobj = (BPy_BezTriple *)value;
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
BezTriple *newb = MEM_callocN( (icu->totvert+1)*sizeof(BezTriple),
"BPyBeztriple" );
if( icu->bezt ) {
Bugfix #4906 Python API bug: Importing ipo curves did a memcpy() on a 1 item too large data block. I wonder how IpoCurve_append() would have ever worked...
2006-08-20 11:02:31 +00:00
memcpy( newb, icu->bezt, ( icu->totvert )*sizeof( BezTriple ) );
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
MEM_freeN( icu->bezt );
}
icu->bezt = newb;
memcpy( &icu->bezt[icu->totvert], bobj->beztriple,
sizeof( BezTriple ) );
icu->totvert++;
calchandles_ipocurve( icu );
/* otherwise try to get two floats and add to list */
} else {
PyObject *xobj, *yobj;
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
xobj = PyNumber_Float( PyTuple_GetItem( value, 0 ) );
yobj = PyNumber_Float( PyTuple_GetItem( value, 1 ) );
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
if( !xobj || !yobj )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"expected tuple of floats" );
x = (float)PyFloat_AsDouble( xobj );
Python API ---------- Fix memleak caused by missing Py_DECREFs (good catch, Campbell).
2007-04-05 04:34:41 +00:00
Py_DECREF( xobj );
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
y = (float)PyFloat_AsDouble( yobj );
Python API ---------- Fix memleak caused by missing Py_DECREFs (good catch, Campbell).
2007-04-05 04:34:41 +00:00
Py_DECREF( yobj );
A user submitted a BVH file that took a long time to import (I didnt end up finishing since it was so slow) this is mainly because adding pose keyframes recalculates every handle so importing became increasingly slow. added a 'fast' argument to insertkey that python api's insertPoseKey can make use of since it alredy accepts a 'fast' option. The ~4450 frame, 31 bone BVH imports in ~108sec now Seperated editmode switch statement in space.c's event handling, if editmode is disabled, or the images is a render or composite, UV editing operations are ignored. In previous releases it has given an annoying warning if selecting or scaling is attempted when out of UV/Face mode.
2007-09-18 06:41:29 +00:00
insert_vert_icu( icu, x, y, 0);
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
}
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
Py_RETURN_NONE;
reincorporation in the cvs of modifications which had been lost.
2003-07-21 00:08:30 +00:00
}
New IPO methods. Ipo.delCurve( curve_name ) deletes named curve from IPO. Ipocurve.delBezier( int ) deletes point at index from Ipocurve. Contributed by Ken Hughes (khughes). Thanks!
2005-04-24 19:03:39 +00:00
/*
Function: IpoCurve_delBezier
Bpy: Blender.Ipocurve.delBezier(0)
Delete an BezTriple from an IPO curve.
example:
ipo = Blender.Ipo.Get('ObIpo')
cu = ipo.getCurve('LocX')
cu.delBezier(0)
*/
static PyObject *IpoCurve_delBezier( C_IpoCurve * self, PyObject * args )
{
int index;
if( !PyArg_ParseTuple( args, "i", &index ) )
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
return EXPP_ReturnPyObjError( PyExc_TypeError,
"expected int argument" );
New IPO methods. Ipo.delCurve( curve_name ) deletes named curve from IPO. Ipocurve.delBezier( int ) deletes point at index from Ipocurve. Contributed by Ken Hughes (khughes). Thanks!
2005-04-24 19:03:39 +00:00
/* if index is negative, count from end of list */
if( index < 0 )
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
index += self->ipocurve->totvert;
New IPO methods. Ipo.delCurve( curve_name ) deletes named curve from IPO. Ipocurve.delBezier( int ) deletes point at index from Ipocurve. Contributed by Ken Hughes (khughes). Thanks!
2005-04-24 19:03:39 +00:00
/* check range of index */
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
if( index < 0 || index > self->ipocurve->totvert - 1 )
return EXPP_ReturnPyObjError( PyExc_IndexError,
"index outside of list" );
New IPO methods. Ipo.delCurve( curve_name ) deletes named curve from IPO. Ipocurve.delBezier( int ) deletes point at index from Ipocurve. Contributed by Ken Hughes (khughes). Thanks!
2005-04-24 19:03:39 +00:00
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
del_beztriple( self->ipocurve, index );
New IPO methods. Ipo.delCurve( curve_name ) deletes named curve from IPO. Ipocurve.delBezier( int ) deletes point at index from Ipocurve. Contributed by Ken Hughes (khughes). Thanks!
2005-04-24 19:03:39 +00:00
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
Py_RETURN_NONE;
New IPO methods. Ipo.delCurve( curve_name ) deletes named curve from IPO. Ipocurve.delBezier( int ) deletes point at index from Ipocurve. Contributed by Ken Hughes (khughes). Thanks!
2005-04-24 19:03:39 +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
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
static PyObject *IpoCurve_Recalc( C_IpoCurve * self )
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
{
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
IpoCurve *icu = self->ipocurve;
fix for #1123 by Roland Hess (harkyman) Testing has not convinced me this is a complete solution to the Ipo Curve handle issue, but it does seem to make things better for curves created via python. We will probably need to revisit this, especially if we expose the curve handles in the bpy interface.
2004-04-29 04:50:28 +00:00
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
/* testhandles_ipocurve (icu); */
/* call calchandles_* instead of testhandles_* */
/* I'm not sure this is a complete solution but since we do not */
/* deal with curve handles right now, it seems ok */
calchandles_ipocurve( icu );
-- fix small problem with Ipocurve.recalc(); recomputed handles but did not re-sort control points (also added reminder in BezTriple doc that script users need to call recalc themselves)
2005-11-17 19:10:40 +00:00
sort_time_ipocurve( icu );
fix for #1123 by Roland Hess (harkyman) Testing has not convinced me this is a complete solution to the Ipo Curve handle issue, but it does seem to make things better for curves created via python. We will probably need to revisit this, especially if we expose the curve handles in the bpy interface.
2004-04-29 04:50:28 +00:00
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
Py_INCREF( Py_None );
return Py_None;
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
}
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
static PyObject *IpoCurve_getName( C_IpoCurve * self )
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
{
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
switch ( self->ipocurve->blocktype ) {
case ID_OB:
return PyString_FromString( getname_ob_ei( self->ipocurve->adrcode, 1 ) ); /* solve: what if EffX/Y/Z are wanted? */
case ID_TE:
return PyString_FromString( getname_tex_ei
( self->ipocurve->adrcode ) );
case ID_LA:
return PyString_FromString( getname_la_ei
( self->ipocurve->adrcode ) );
case ID_MA:
return PyString_FromString( getname_mat_ei
( self->ipocurve->adrcode ) );
case ID_CA:
return PyString_FromString( getname_cam_ei
( self->ipocurve->adrcode ) );
case ID_WO:
return PyString_FromString( getname_world_ei
( self->ipocurve->adrcode ) );
Stupid me! Committed in wrong console with wrong dir... here's the rest of all files for the Ipo/Action/NLA makeover...
2005-10-10 18:05:30 +00:00
case ID_PO:
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
return PyString_FromString( getname_ac_ei
( self->ipocurve->adrcode ) );
case ID_CU:
return PyString_FromString( getname_cu_ei
( self->ipocurve->adrcode ) );
case ID_KE:
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
return PyString_FromString( get_key_curvename( self->ipocurve ) );
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
case ID_SEQ:
return PyString_FromString( getname_seq_ei
( self->ipocurve->adrcode ) );
Stupid me! Committed in wrong console with wrong dir... here's the rest of all files for the Ipo/Action/NLA makeover...
2005-10-10 18:05:30 +00:00
case ID_CO:
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
return PyString_FromString( getname_co_ei
( self->ipocurve->adrcode ) );
default:
return EXPP_ReturnPyObjError( PyExc_TypeError,
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
"This function doesn't support this ipocurve type yet" );
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
}
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
}
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
static PyObject *IpoCurve_getPoints( C_IpoCurve * self )
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 API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
BezTriple *bezt;
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
PyObject *po;
int i;
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
PyObject *list = PyList_New( self->ipocurve->totvert );
if( !list )
return EXPP_ReturnPyObjError( PyExc_MemoryError,
"PyList_New() failed" );
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 API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
for( bezt = self->ipocurve->bezt, i = 0;
i < self->ipocurve->totvert; i++, bezt++ ) {
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
po = BezTriple_CreatePyObject( bezt );
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
if( !po ) {
Py_DECREF( list );
more memory leak fixes, though only a few are likely to happen
2007-05-27 21:33:48 +00:00
return NULL; /* This is okay since the error is alredy set */
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
}
PyList_SET_ITEM( list, i, po );
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
}
return list;
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
}
added comparison function to many python types so you can do == and =!
2006-10-06 16:48:28 +00:00
/*****************************************************************************/
/* Function: IpoCurve_compare */
/* Description: This compares 2 python types, == or != only. */
/*****************************************************************************/
static int IpoCurve_compare( C_IpoCurve * a, C_IpoCurve * b )
{
return ( a->ipocurve == b->ipocurve ) ? 0 : -1;
}
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
/*****************************************************************************/
/* Function: IpoCurve_repr */
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
/* Description: This is a callback function for the C_IpoCurve type. It */
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
/* builds a meaningful string to represent ipocurve objects. */
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
/*****************************************************************************/
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
static PyObject *IpoCurve_repr( C_IpoCurve * self )
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
{
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
return PyString_FromFormat( "[IpoCurve \"%s\"]",
getIpoCurveName( self->ipocurve ) );
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
}
/* Three Python IpoCurve_Type helper functions needed by the Object module: */
/*****************************************************************************/
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
/* Function: IpoCurve_CreatePyObject */
/* Description: This function will create a new C_IpoCurve from an existing */
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
/* Blender ipo structure. */
/*****************************************************************************/
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
PyObject *IpoCurve_CreatePyObject( IpoCurve * icu )
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
{
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
C_IpoCurve *pyipo;
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
pyipo = ( C_IpoCurve * ) PyObject_NEW( C_IpoCurve, &IpoCurve_Type );
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
if( !pyipo )
return EXPP_ReturnPyObjError( PyExc_MemoryError,
"couldn't create C_IpoCurve object" );
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
pyipo->ipocurve = icu;
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
return ( PyObject * ) pyipo;
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
}
/*****************************************************************************/
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
/* Function: IpoCurve_FromPyObject */
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
/* Description: This function returns the Blender ipo from the given */
/* PyObject. */
/*****************************************************************************/
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
IpoCurve *IpoCurve_FromPyObject( PyObject * pyobj )
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
{
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
return ( ( C_IpoCurve * ) pyobj )->ipocurve;
Nex modules added to keep a minimal compatibility with 227 api
2003-07-19 08:29:55 +00:00
}
patch for bug #1347. IpoCurve.evaluate() missing/disappeared. Contributed by Philip Wainwright.
2004-06-06 19:42:12 +00:00
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
/*
* get the value of an Ipocurve at a particular time
*/
static PyObject *IpoCurve_getCurval( C_IpoCurve * self, PyObject * args )
{
float time;
PyObject *pyfloat = PyNumber_Float( args );
if( !pyfloat )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument" );
time = ( float )PyFloat_AS_DOUBLE( pyfloat );
Py_DECREF( pyfloat );
return PyFloat_FromDouble( ( double ) eval_icu( self->ipocurve, time ) );
}
/*
* set the value of an Ipocurve at a particular time
*/
static int IpoCurve_setCurval( C_IpoCurve * self, PyObject * key,
PyObject * value )
{
float time, curval;
PyObject *pyfloat;
/* make sure time, curval are both floats */
pyfloat = PyNumber_Float( key );
if( !pyfloat )
return EXPP_ReturnIntError( PyExc_TypeError,
"expected float key" );
time = ( float )PyFloat_AS_DOUBLE( pyfloat );
Py_DECREF( pyfloat );
pyfloat = PyNumber_Float( value );
if( !pyfloat )
return EXPP_ReturnIntError( PyExc_TypeError,
"expected float argument" );
curval = ( float )PyFloat_AS_DOUBLE( pyfloat );
Py_DECREF( pyfloat );
/* insert a key at the specified time */
A user submitted a BVH file that took a long time to import (I didnt end up finishing since it was so slow) this is mainly because adding pose keyframes recalculates every handle so importing became increasingly slow. added a 'fast' argument to insertkey that python api's insertPoseKey can make use of since it alredy accepts a 'fast' option. The ~4450 frame, 31 bone BVH imports in ~108sec now Seperated editmode switch statement in space.c's event handling, if editmode is disabled, or the images is a render or composite, UV editing operations are ignored. In previous releases it has given an annoying warning if selecting or scaling is attempted when out of UV/Face mode.
2007-09-18 06:41:29 +00:00
insert_vert_icu( self->ipocurve, time, curval, 0);
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
allspace(REMAKEIPO, 0);
return 0;
}
patch for bug #1347. IpoCurve.evaluate() missing/disappeared. Contributed by Philip Wainwright.
2004-06-06 19:42:12 +00:00
/***************************************************************************/
/* Function: IpoCurve_evaluate( time ) */
/* Description: Evaluates IPO curve at the given time. */
/***************************************************************************/
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
static PyObject *IpoCurve_evaluate( C_IpoCurve * self, PyObject * args )
patch for bug #1347. IpoCurve.evaluate() missing/disappeared. Contributed by Philip Wainwright.
2004-06-06 19:42:12 +00:00
{
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
float time = 0;
double eval = 0;
patch for bug #1347. IpoCurve.evaluate() missing/disappeared. Contributed by Philip Wainwright.
2004-06-06 19:42:12 +00:00
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
/* expecting float */
if( !PyArg_ParseTuple( args, "f", &time ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError, "expected float argument" ) );
patch for bug #1347. IpoCurve.evaluate() missing/disappeared. Contributed by Philip Wainwright.
2004-06-06 19:42:12 +00:00
Another round in the Great BPy Cleanup: Run everything thru indent to cleanup spaces vs tabs. Clean up some of the comments by hand. BGL.c was not touched due to all that macro wackyness. There are no functional changes to the code. Pre-indent versions of source are tagged with tag bpy-cleanup-20040925 , just in case.
2004-09-25 20:30:40 +00:00
eval = ( double ) eval_icu( self->ipocurve, time );
return PyFloat_FromDouble( eval );
patch for bug #1347. IpoCurve.evaluate() missing/disappeared. Contributed by Philip Wainwright.
2004-06-06 19:42:12 +00:00
}
New IPO methods. Ipo.delCurve( curve_name ) deletes named curve from IPO. Ipocurve.delBezier( int ) deletes point at index from Ipocurve. Contributed by Ken Hughes (khughes). Thanks!
2005-04-24 19:03:39 +00:00
Quick PyAPI patch: Now it is possible to clean IPO-curves using the call: icu.clean() There's an optional value to specify the threshold to use for cleaning. This just wraps the internal clean_ipo_curve() function.
2008-10-11 12:17:16 +00:00
/***************************************************************************/
/* Function: IpoCurve_clean( thresh ) */
/* Description: Cleans IPO curve with the (optional) threshold. */
/***************************************************************************/
static PyObject *IpoCurve_clean( C_IpoCurve * self, PyObject * args )
{
float thresh, othresh;
thresh= othresh= G.scene->toolsettings->clean_thresh;
/* expecting float */
if( !PyArg_ParseTuple( args, "|f", &thresh ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError, "expected float argument" ) );
/* set IPO-cleaning threshold based on value provided by user (temporarily) */
G.scene->toolsettings->clean_thresh= thresh;
clean_ipo_curve( self->ipocurve );
G.scene->toolsettings->clean_thresh= othresh;
Py_RETURN_NONE;
}
Added some extra parameter checking in Ipo driver code.
2005-12-06 05:42:23 +00:00
static PyObject *IpoCurve_getDriver( C_IpoCurve * self )
{
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
if( !self->ipocurve->driver )
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
return PyInt_FromLong( 0 );
PyAPI driverExpression: added "ipocurve.driver = 2" to set the curve to use driver python expressions. added ipocurve.driverExpression - the string to run.
2006-12-25 10:44:28 +00:00
else {
if (self->ipocurve->driver->type == IPO_DRIVER_TYPE_NORMAL)
return PyInt_FromLong( 1 );
if (self->ipocurve->driver->type == IPO_DRIVER_TYPE_PYTHON)
return PyInt_FromLong( 2 );
}
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"unknown driver type, internal error" );
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
}
PyAPI driverExpression: added "ipocurve.driver = 2" to set the curve to use driver python expressions. added ipocurve.driverExpression - the string to run.
2006-12-25 10:44:28 +00:00
/*
sets the driver to
0: disabled
1: enabled (object)
2: enabled (python expression)
*/
Added some extra parameter checking in Ipo driver code.
2005-12-06 05:42:23 +00:00
static int IpoCurve_setDriver( C_IpoCurve * self, PyObject * args )
{
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
IpoCurve *ipo = self->ipocurve;
PyAPI driverExpression: added "ipocurve.driver = 2" to set the curve to use driver python expressions. added ipocurve.driverExpression - the string to run.
2006-12-25 10:44:28 +00:00
int type;
replace PyInt_CheckExact with PyInt_Check, same for floats and strings so subclass and C/subtypes work. was reported as a bug a while ago.
2007-07-01 05:41:23 +00:00
if( !PyInt_Check( args ) )
Added some extra parameter checking in Ipo driver code.
2005-12-06 05:42:23 +00:00
return EXPP_ReturnIntError( PyExc_TypeError,
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
"expected int argument 0 or 1 " );
PyAPI driverExpression: added "ipocurve.driver = 2" to set the curve to use driver python expressions. added ipocurve.driverExpression - the string to run.
2006-12-25 10:44:28 +00:00
type = PyInt_AS_LONG( args );
if (type < 0 || type > 2)
return EXPP_ReturnIntError( PyExc_ValueError,
"expected int argument 0, 1 or 2" );
if (type==0) { /* disable driver */
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
if( ipo->driver ) {
MEM_freeN( ipo->driver );
ipo->driver = NULL;
Added some extra parameter checking in Ipo driver code.
2005-12-06 05:42:23 +00:00
}
PyAPI driverExpression: added "ipocurve.driver = 2" to set the curve to use driver python expressions. added ipocurve.driverExpression - the string to run.
2006-12-25 10:44:28 +00:00
} else {
if( !ipo->driver ) { /*add driver if its not there */
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
ipo->driver = MEM_callocN( sizeof(IpoDriver), "ipo driver" );
ipo->driver->blocktype = ID_OB;
ipo->driver->adrcode = OB_LOC_X;
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
}
PyAPI driverExpression: added "ipocurve.driver = 2" to set the curve to use driver python expressions. added ipocurve.driverExpression - the string to run.
2006-12-25 10:44:28 +00:00
if (type==1 && ipo->driver->type != IPO_DRIVER_TYPE_NORMAL) {
ipo->driver->type = IPO_DRIVER_TYPE_NORMAL;
ipo->driver->ob = NULL;
ipo->driver->flag &= ~IPO_DRIVER_FLAG_INVALID;
} else if (type==2 && ipo->driver->type != IPO_DRIVER_TYPE_PYTHON) {
ipo->driver->type = IPO_DRIVER_TYPE_PYTHON;
/* we should probably set ipo->driver->ob, but theres no way to do it properly */
ipo->driver->ob = NULL;
}
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
}
PyAPI driverExpression: added "ipocurve.driver = 2" to set the curve to use driver python expressions. added ipocurve.driverExpression - the string to run.
2006-12-25 10:44:28 +00:00
Added some extra parameter checking in Ipo driver code.
2005-12-06 05:42:23 +00:00
return 0;
}
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
Added some extra parameter checking in Ipo driver code.
2005-12-06 05:42:23 +00:00
static PyObject *IpoCurve_getDriverObject( C_IpoCurve * self )
{
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
IpoCurve *ipo = self->ipocurve;
Added some extra parameter checking in Ipo driver code.
2005-12-06 05:42:23 +00:00
if( ipo->driver )
return Object_CreatePyObject( ipo->driver->ob );
Py_RETURN_NONE;
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
}
Added some extra parameter checking in Ipo driver code.
2005-12-06 05:42:23 +00:00
static int IpoCurve_setDriverObject( C_IpoCurve * self, PyObject * arg )
{
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
IpoCurve *ipo = self->ipocurve;
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
if( !ipo->driver )
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
return EXPP_ReturnIntError( PyExc_RuntimeError,
"This IpoCurve does not have an active driver" );
if(!BPy_Object_Check(arg) )
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
return EXPP_ReturnIntError( PyExc_RuntimeError,
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
"expected an object argument" );
Added some extra parameter checking in Ipo driver code.
2005-12-06 05:42:23 +00:00
ipo->driver->ob = ((BPy_Object *)arg)->object;
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
DAG_scene_sort(G.scene);
return 0;
}
Added some extra parameter checking in Ipo driver code.
2005-12-06 05:42:23 +00:00
static PyObject *IpoCurve_getDriverChannel( C_IpoCurve * self )
{
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
if( !self->ipocurve->driver )
Added some extra parameter checking in Ipo driver code.
2005-12-06 05:42:23 +00:00
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"This IpoCurve does not have an active driver" );
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
return PyInt_FromLong( self->ipocurve->driver->adrcode );
}
Added some extra parameter checking in Ipo driver code.
2005-12-06 05:42:23 +00:00
static int IpoCurve_setDriverChannel( C_IpoCurve * self, PyObject * args )
{
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
IpoCurve *ipo = self->ipocurve;
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
short param;
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
if( !ipo->driver )
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
return EXPP_ReturnIntError( PyExc_RuntimeError,
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
"This IpoCurve does not have an active driver" );
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
replace PyInt_CheckExact with PyInt_Check, same for floats and strings so subclass and C/subtypes work. was reported as a bug a while ago.
2007-07-01 05:41:23 +00:00
if( !PyInt_Check( args ) )
Added some extra parameter checking in Ipo driver code.
2005-12-06 05:42:23 +00:00
return EXPP_ReturnIntError( PyExc_TypeError,
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
"expected int argument" );
param = (short)PyInt_AS_LONG ( args );
if( ( param >= OB_LOC_X && param <= OB_LOC_Z )
|| ( param >= OB_ROT_X && param <= OB_ROT_Z )
|| ( param >= OB_SIZE_X && param <= OB_SIZE_Z ) ) {
ipo->driver->adrcode = (short)PyInt_AS_LONG ( args );
return 0;
}
Added some extra parameter checking in Ipo driver code.
2005-12-06 05:42:23 +00:00
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
return EXPP_ReturnIntError( PyExc_ValueError, "invalid int argument" );
}
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
PyAPI driverExpression: added "ipocurve.driver = 2" to set the curve to use driver python expressions. added ipocurve.driverExpression - the string to run.
2006-12-25 10:44:28 +00:00
static PyObject *IpoCurve_getDriverExpression( C_IpoCurve * self )
{
IpoCurve *ipo = self->ipocurve;
if( ipo->driver && ipo->driver->type == IPO_DRIVER_TYPE_PYTHON )
return PyString_FromString( ipo->driver->name );
Py_RETURN_NONE;
}
static int IpoCurve_setDriverExpression( C_IpoCurve * self, PyObject * arg )
{
IpoCurve *ipo = self->ipocurve;
char *exp; /* python expression */
if( !ipo->driver )
return EXPP_ReturnIntError( PyExc_RuntimeError,
"This IpoCurve does not have an active driver" );
if (ipo->driver->type != IPO_DRIVER_TYPE_PYTHON)
return EXPP_ReturnIntError( PyExc_RuntimeError,
"This IpoCurve is not a python expression set the driver attribute to 2" );
if(!PyString_Check(arg) )
return EXPP_ReturnIntError( PyExc_RuntimeError,
"expected a string argument" );
exp = PyString_AsString(arg);
if (strlen(exp)>127)
return EXPP_ReturnIntError( PyExc_ValueError,
"string is too long, use 127 characters or less" );
driverExpression - strcpy on wrong type (my bad) fixed. added .sel bool for Ipo curves.
2007-01-13 04:53:41 +00:00
strcpy(ipo->driver->name, exp);
PyAPI driverExpression: added "ipocurve.driver = 2" to set the curve to use driver python expressions. added ipocurve.driverExpression - the string to run.
2006-12-25 10:44:28 +00:00
return 0;
}
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
static PyObject *M_IpoCurve_ExtendDict( void )
{
PyObject *EM = PyConstant_New( );
if( EM ) {
BPy_constant *d = ( BPy_constant * ) EM;
PyConstant_Insert( d, "CONST", PyInt_FromLong( IPO_HORIZ ) );
PyConstant_Insert( d, "EXTRAP", PyInt_FromLong( IPO_DIR ) );
PyConstant_Insert( d, "CYCLIC", PyInt_FromLong( IPO_CYCL ) );
PyConstant_Insert( d, "CYCLIC_EXTRAP", PyInt_FromLong( IPO_CYCLX ) );
}
return EM;
}
static PyObject *M_IpoCurve_InterpDict( void )
{
PyObject *IM = PyConstant_New( );
if( IM ) {
BPy_constant *d = ( BPy_constant * ) IM;
PyConstant_Insert( d, "CONST", PyInt_FromLong( IPO_CONST ) );
PyConstant_Insert( d, "LINEAR", PyInt_FromLong( IPO_LIN ) );
PyConstant_Insert( d, "BEZIER", PyInt_FromLong( IPO_BEZ ) );
}
return IM;
}
/*****************************************************************************/
/* Function: IpoCurve_Init */
/*****************************************************************************/
PyObject *IpoCurve_Init( void )
{
PyObject *submodule;
PyObject *ExtendTypes = M_IpoCurve_ExtendDict( );
PyObject *InterpTypes = M_IpoCurve_InterpDict( );
if( PyType_Ready( &IpoCurve_Type ) < 0)
return NULL;
submodule =
Py_InitModule3( "Blender.IpoCurve", M_IpoCurve_methods,
M_IpoCurve_doc );
PyModule_AddIntConstant( submodule, "LOC_X", OB_LOC_X );
PyModule_AddIntConstant( submodule, "LOC_Y", OB_LOC_Y );
PyModule_AddIntConstant( submodule, "LOC_Z", OB_LOC_Z );
PyModule_AddIntConstant( submodule, "ROT_X", OB_ROT_X );
PyModule_AddIntConstant( submodule, "ROT_Y", OB_ROT_Y );
PyModule_AddIntConstant( submodule, "ROT_Z", OB_ROT_Z );
PyModule_AddIntConstant( submodule, "SIZE_X", OB_SIZE_X );
PyModule_AddIntConstant( submodule, "SIZE_Y", OB_SIZE_Y );
PyModule_AddIntConstant( submodule, "SIZE_Z", OB_SIZE_Z );
if( ExtendTypes )
PyModule_AddObject( submodule, "ExtendTypes", ExtendTypes );
if( InterpTypes )
PyModule_AddObject( submodule, "InterpTypes", InterpTypes );
return submodule;
}
/*
*/
static PyObject *IpoCurve_newgetInterp( C_IpoCurve * self )
{
remove unneeded checks from the python API
2007-06-29 08:59:26 +00:00
return PyInt_FromLong( self->ipocurve->ipo );
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
}
static int IpoCurve_newsetInterp( C_IpoCurve * self, PyObject * value )
{
return EXPP_setIValueRange( value, &self->ipocurve->ipo,
IPO_CONST, IPO_BEZ, 'h' );
}
static PyObject *IpoCurve_newgetExtend( C_IpoCurve * self )
{
remove unneeded checks from the python API
2007-06-29 08:59:26 +00:00
return PyInt_FromLong( self->ipocurve->extrap );
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
}
static int IpoCurve_newsetExtend( C_IpoCurve * self, PyObject * value )
{
return EXPP_setIValueRange( value, &self->ipocurve->extrap,
IPO_HORIZ, IPO_CYCLX, 'h' );
}
driverExpression - strcpy on wrong type (my bad) fixed. added .sel bool for Ipo curves.
2007-01-13 04:53:41 +00:00
static PyObject *IpoCurve_getFlag( C_IpoCurve * self, void *type )
{
Used GET_INT_FROM_POINTER to get rid of many warnings that only occurred with 64bit os's Also use Py_ssize_t which we might need to define for older python's
2008-04-17 21:14:55 +00:00
if (self->ipocurve->flag & GET_INT_FROM_POINTER(type))
driverExpression - strcpy on wrong type (my bad) fixed. added .sel bool for Ipo curves.
2007-01-13 04:53:41 +00:00
Py_RETURN_TRUE;
else
Py_RETURN_FALSE;
}
static int IpoCurve_setFlag( C_IpoCurve * self, PyObject *value, void *type )
{
int param = PyObject_IsTrue( value );
From stable Revision: 11237 http://projects.blender.org/plugins/scmsvn/viewcvs.php?view=rev&root=bf-blender&revision=11237 Author: campbellbarton Date: 2007-07-12 13:05:31 +0200 (Thu, 12 Jul 2007) Log Message: ----------- PyObject_IsTrue was missing a check for an error return value in many cases.
2007-07-12 11:51:21 +00:00
if( param == -1 )
return EXPP_ReturnIntError( PyExc_TypeError,
"expected True/False or 0/1" );
driverExpression - strcpy on wrong type (my bad) fixed. added .sel bool for Ipo curves.
2007-01-13 04:53:41 +00:00
if (param)
Used GET_INT_FROM_POINTER to get rid of many warnings that only occurred with 64bit os's Also use Py_ssize_t which we might need to define for older python's
2008-04-17 21:14:55 +00:00
self->ipocurve->flag |= GET_INT_FROM_POINTER(type);
driverExpression - strcpy on wrong type (my bad) fixed. added .sel bool for Ipo curves.
2007-01-13 04:53:41 +00:00
else
Used GET_INT_FROM_POINTER to get rid of many warnings that only occurred with 64bit os's Also use Py_ssize_t which we might need to define for older python's
2008-04-17 21:14:55 +00:00
self->ipocurve->flag &= ~GET_INT_FROM_POINTER(type);
driverExpression - strcpy on wrong type (my bad) fixed. added .sel bool for Ipo curves.
2007-01-13 04:53:41 +00:00
return 0;
}
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
/* #####DEPRECATED###### */
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
static PyObject *IpoCurve_addBezier( C_IpoCurve * self, PyObject * value )
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
{
float x, y;
int npoints;
IpoCurve *icu;
BezTriple *bzt, *tmp;
static char name[10] = "mlml";
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
if( !PyArg_ParseTuple( value, "ff", &x, &y ) )
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
return ( EXPP_ReturnPyObjError
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
( PyExc_TypeError, "expected a tuple of 2 floats" ) );
===Python API=== New Ipo and IpoCurve API. Ipo and IpoCurve objects support the [] operator, for accessing the curves of a particular Ipo and for accessing the value of an IpoCurve at a specific time. Both modules were also "tp_getset"-ified. Also, code for an alternative method (Antont wanted this) of accessing curves via Ipo attributes is included for now, for people to try and see if it's actually preferable to the Ipo [] operator. These are all new additions; nothing was intentionally removed from the API. If you find the something in the existing API has changed, let me know.
2006-04-21 20:27:52 +00:00
icu = self->ipocurve;
npoints = icu->totvert;
tmp = icu->bezt;
icu->bezt = MEM_mallocN( sizeof( BezTriple ) * ( npoints + 1 ), name );
if( tmp ) {
memmove( icu->bezt, tmp, sizeof( BezTriple ) * npoints );
MEM_freeN( tmp );
}
memmove( icu->bezt + npoints, icu->bezt, sizeof( BezTriple ) );
icu->totvert++;
bzt = icu->bezt + npoints;
bzt->vec[0][0] = x - 1;
bzt->vec[1][0] = x;
bzt->vec[2][0] = x + 1;
bzt->vec[0][1] = y - 1;
bzt->vec[1][1] = y;
bzt->vec[2][1] = y + 1;
/* set handle type to Auto */
bzt->h1 = HD_AUTO;
bzt->h2 = HD_AUTO;
Python PyMethodDef supports single argument methods (METH_O) but was using METH_VARARGS everywhere and getting the single args from the tuple. Use METH_O where applicable.
2007-06-16 12:24:41 +00:00
Py_RETURN_NONE;
Python API Additions New Ipo Drivers access in IpoCurve key.getChannelIpo(index) returns the ipocurve of a given shape index Docs included for usage :)
2005-10-26 16:30:50 +00:00
}
Copy Permalink