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
b89035906daa352ac8eae4c157c3dd6f61b7ad62
blender-archive/source/blender/python/api2_2x/gen_utils.c
Joseph Gilbert b89035906d Mathutils update 
- also included is some fixes for preprocessor inclues and some clean up of the previous commit

-rewrite and bugfixes
  ----------------------------------
  Here's my changelog:
  -fixed Rand() so that it doesn't seed everytime and should generate better random numbers
  - changed a few error return types to something more appropriate
  - clean up of uninitialized variables & removal of unneccessary objects
  - NMesh returns wrapped vectors now
  - World returns wrapped matrices now
  - Object.getEuler() and Object.getBoundingBox() return Wrapped data when data is present
  - Object.getMatrix() returns wrapped data if it's worldspace, 'localspace' returns a new matrix
  - Vector, Euler, Mat, Quat, call all now internally wrap object without destroying internal datablocks
  - Removed memory allocation (unneeded) from all methods
  - Vector's resize methods are only applicable to new vectors not wrapped data.
  - Matrix(), Quat(), Euler(), Vector() now accepts ANY sequence list, including tuples, list, or a self object to copy - matrices accept multiple sequences
  - Fixed Slerp() so that it now works correctly values are clamped between 0 and 1
  - Euler.rotate does internal rotation now
  - Slice assignment now works better for all types
  - Vector * Vector and Quat * Quat are defined and return the DOT product
  - Mat * Vec and Vec * Mat are defined now
  - Moved #includes to .c file from headers. Also fixed prototypes in mathutils
  - Added new helper functions for incref'ing to genutils
  - Major cleanup of header files includes - include Mathutils.h for access to math types
  - matrix.toQuat() and .toEuler() now fixed take appropriate matrix sizes
  - Matrix() with no parameters now returns an identity matrix by default not a zero matrix
  - printf() now prints with 6 digits instead of 4
  - printf() now prints output with object descriptor
  - Matrices now support [x][y] assignment (e.g. matrix[x][y] = 5.4)
  - Matrix[index] = value now expectes a sequence not an integer. This will now set a ROW of the matrix through a sequence.  index cannot go above the row size of the matrix.
  - slice operations on matrices work with sequences now (rows of the matrix) example:  mymatrix[0:2] returns a list of 2 wrapped vectors with access to the matrix data.
  - slice assignment will no longer modify the data if the assignment operation fails
  - fixed error in matrix * scalar multiplication
  - euler.toMatrix(), toQuat() no longer causes "creep" from repeated use
  - Wrapped data will generate wrapped objects when toEuler(), toQuat(), toMatrix() is used
  - Quats can be created with angle/axis, axis/angle
  - 4x4 matrices can be multiplied by 3D vectors (by popular demand :))
  - vec *quat / quat * vec is now defined
  - vec.magnitude alias for vec.length
  - all self, internal methods return a pointer to self now so you can do print vector.internalmethod() or vector.internalmethod().nextmethod() (no more print matrix.inverse() returning 'none')
  - these methods have been deprecated (still functioning but suggested to use the corrected functionality):
    * CopyVec() - replaced by Vector() functionality
    * CopyMat() - replaced by Matrix() functionality
    * CopyQuat() - replace by Quaternion() functionality
    * CopyEuler() - replaced by Euler() functionality
    * RotateEuler() - replaced by Euler.rotate() funtionality
    * MatMultVec() - replaced by matrix * vector
    * VecMultMat() - replaced by vector * matrix
  -  New struct containers references to python object data or internally allocated blender data for wrapping
  * Explaination here:  math structs now function as a 'simple wrapper' or a 'py_object' - data that is created on the fly will now be a 'py_object' with its memory managed by python
  *    otherwise if the data is returned by blender's G.main then the math object is a 'simple wrapper' and data can be accessed directly from the struct just like other python objects.
2005-07-14 03:34:56 +00:00

539 lines
15 KiB
C
Raw Blame History

/*
* $Id$
*
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version. The Blender
* Foundation also sells licenses for use in proprietary software under
* the Blender License. See http://www.blender.org/BL/ for information
* about this.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
*
* This is a new part of Blender.
*
* Contributor(s): Michel Selten, Willian P. Germano, Alex Mole, Ken Hughes
*
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
#include "DNA_text_types.h"
#include "MEM_guardedalloc.h"
#include "BLI_blenlib.h"
#include "BIF_space.h"
#include "gen_utils.h"
#include "constant.h"
/*****************************************************************************/
/* Description: This function clamps an int to the given interval */
/* [min, max]. */
/*****************************************************************************/
int EXPP_ClampInt( int value, int min, int max )
{
if( value < min )
return min;
else if( value > max )
return max;
return value;
}
/*****************************************************************************/
/* Description: This function clamps a float to the given interval */
/* [min, max]. */
/*****************************************************************************/
float EXPP_ClampFloat( float value, float min, float max )
{
if( value < min )
return min;
else if( value > max )
return max;
return value;
}
/*****************************************************************************/
/* Description: This function returns true if both given strings are equal, */
/* otherwise it returns false. */
/*****************************************************************************/
int StringEqual( const char *string1, const char *string2 )
{
return ( strcmp( string1, string2 ) == 0 );
}
/*****************************************************************************/
/* Description: This function returns the name of the given ID struct */
/* without the Object type identifying characters prepended. */
/*****************************************************************************/
char *GetIdName( ID * id )
{
return ( ( id->name ) + 2 );
}
/*****************************************************************************/
/* Description: This function returns the ID of the object with given name */
/* from a given list. */
/*****************************************************************************/
ID *GetIdFromList( ListBase * list, char *name )
{
ID *id = list->first;
while( id ) {
if( strcmp( name, id->name + 2 ) == 0 )
break;
id = id->next;
}
return id;
}
/*****************************************************************************/
/* Description: These functions set an internal string with the given type */
/* and error_msg arguments. */
/*****************************************************************************/
PyObject *EXPP_ReturnPyObjError( PyObject * type, char *error_msg )
{ /* same as above, just to change its name smoothly */
PyErr_SetString( type, error_msg );
return NULL;
}
int EXPP_ReturnIntError( PyObject * type, char *error_msg )
{
PyErr_SetString( type, error_msg );
return -1;
}
/*****************************************************************************/
/* Description: This function increments the reference count of the given */
/* Python object (usually Py_None) and returns it. */
/*****************************************************************************/
PyObject *EXPP_incr_ret( PyObject * object )
{
Py_INCREF( object );
return ( object );
}
/* return Py_False - to avoid warnings, we use the fact that
* 0 == False in Python: */
PyObject *EXPP_incr_ret_False()
{
return Py_BuildValue("i", 0);
}
/* return Py_True - to avoid warnings, we use the fact that
* 1 == True in Python: */
PyObject *EXPP_incr_ret_True()
{
return Py_BuildValue("i", 1);
}
void EXPP_incr2( PyObject * ob1, PyObject * ob2 )
{
Py_INCREF( ob1 );
Py_INCREF( ob2 );
}
void EXPP_incr3( PyObject * ob1, PyObject * ob2, PyObject * ob3 )
{
Py_INCREF( ob1 );
Py_INCREF( ob2 );
Py_INCREF( ob3 );
}
void EXPP_decr2( PyObject * ob1, PyObject * ob2 )
{
Py_DECREF( ob1 );
Py_DECREF( ob2 );
}
void EXPP_decr3( PyObject * ob1, PyObject * ob2, PyObject * ob3 )
{
Py_DECREF( ob1 );
Py_DECREF( ob2 );
Py_DECREF( ob3 );
}
/*****************************************************************************/
/* Description: This function maps the event identifier to a string. */
/*****************************************************************************/
char *event_to_name( short event )
{
switch ( event ) {
case SCRIPT_FRAMECHANGED:
return "FrameChanged";
case SCRIPT_ONLOAD:
return "OnLoad";
case SCRIPT_ONSAVE:
return "OnSave";
case SCRIPT_REDRAW:
return "Redraw";
case SCRIPT_RENDER:
return "Render";
case SCRIPT_POSTRENDER:
return "PostRender";
default:
return "Unknown";
}
}
/*****************************************************************************/
/* Description: Checks whether all objects in a PySequence are of a same */
/* given type. Returns 0 if not, 1 on success. */
/*****************************************************************************/
int EXPP_check_sequence_consistency( PyObject * seq, PyTypeObject * against )
{
PyObject *ob;
int len = PySequence_Length( seq );
int i, result = 1;
for( i = 0; i < len; i++ ) {
ob = PySequence_GetItem( seq, i );
if( ob == Py_None )
result = 2;
else if( ob->ob_type != against ) {
Py_DECREF( ob );
return 0;
}
Py_DECREF( ob );
}
return result; /* 1 if all of 'against' type, 2 if there are (also) Nones */
}
PyObject *EXPP_tuple_repr( PyObject * self, int size )
{
PyObject *repr, *item;
int i;
/*@ note: a value must be built because the list is decrefed!
* otherwise we have nirvana pointers inside python.. */
repr = PyString_FromString( "" );
if( !repr )
return 0;
item = PySequence_GetItem( self, 0 );
PyString_ConcatAndDel( &repr, PyObject_Repr( item ) );
Py_DECREF( item );
for( i = 1; i < size; i++ ) {
item = PySequence_GetItem( self, i );
PyString_ConcatAndDel( &repr, PyObject_Repr( item ) );
Py_DECREF( item );
}
return repr;
}
/****************************************************************************/
/* Description: searches through a map for a pair with a given name. If the */
/* pair is present, its ival is stored in *ival and nonzero is */
/* returned. If the pair is absent, zero is returned. */
/****************************************************************************/
int EXPP_map_getIntVal( const EXPP_map_pair * map, const char *sval,
int *ival )
{
while( map->sval ) {
if( StringEqual( sval, map->sval ) ) {
*ival = map->ival;
return 1;
}
++map;
}
return 0;
}
/* same as above, but string case is ignored */
int EXPP_map_case_getIntVal( const EXPP_map_pair * map, const char *sval,
int *ival )
{
while( map->sval ) {
if( !BLI_strcasecmp( sval, map->sval ) ) {
*ival = map->ival;
return 1;
}
++map;
}
return 0;
}
/****************************************************************************/
/* Description: searches through a map for a pair with a given name. If the */
/* pair is present, its ival is stored in *ival and nonzero is */
/* returned. If the pair is absent, zero is returned. */
/* note: this function is identical to EXPP_map_getIntVal except that the */
/* output is stored in a short value. */
/****************************************************************************/
int EXPP_map_getShortVal( const EXPP_map_pair * map,
const char *sval, short *ival )
{
while( map->sval ) {
if( StringEqual( sval, map->sval ) ) {
*ival = map->ival;
return 1;
}
++map;
}
return 0;
}
/****************************************************************************/
/* Description: searches through a map for a pair with a given ival. If the */
/* pair is present, a pointer to its name is stored in *sval */
/* and nonzero is returned. If the pair is absent, zero is */
/* returned. */
/****************************************************************************/
int EXPP_map_getStrVal( const EXPP_map_pair * map, int ival,
const char **sval )
{
while( map->sval ) {
if( ival == map->ival ) {
*sval = map->sval;
return 1;
}
++map;
}
return 0;
}
/* Redraw wrappers */
/* this queues redraws if we're not in background mode: */
void EXPP_allqueue(unsigned short event, short val)
{
if (!G.background) allqueue(event, val);
}
/************************************************************************/
/* Scriptlink-related functions, used by scene, object, etc. bpyobjects */
/************************************************************************/
PyObject *EXPP_getScriptLinks( ScriptLink * slink, PyObject * args,
int is_scene )
{
PyObject *list = NULL;
char *eventname = NULL;
int i, event = 0;
/* actually !scriptlink shouldn't happen ... */
if( !slink || !slink->totscript )
return EXPP_incr_ret( Py_None );
if( !PyArg_ParseTuple( args, "s", &eventname ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"expected event name (string) as argument" );
list = PyList_New( 0 );
if( !list )
return EXPP_ReturnPyObjError( PyExc_MemoryError,
"couldn't create PyList!" );
if( !strcmp( eventname, "FrameChanged" ) )
event = SCRIPT_FRAMECHANGED;
else if( !strcmp( eventname, "Redraw" ) )
event = SCRIPT_REDRAW;
else if( !strcmp( eventname, "Render" ) )
event = SCRIPT_RENDER;
else if( is_scene && !strcmp( eventname, "OnLoad" ) )
event = SCRIPT_ONLOAD;
else if( is_scene && !strcmp( eventname, "OnSave" ) )
event = SCRIPT_ONSAVE;
else
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"invalid event name" );
for( i = 0; i < slink->totscript; i++ ) {
if( ( slink->flag[i] == event ) && slink->scripts[i] )
PyList_Append( list,
PyString_FromString( slink->scripts[i]->
name + 2 ) );
}
return list;
}
PyObject *EXPP_clearScriptLinks( ScriptLink * slink, PyObject * args )
{
int i, j, totLinks, deleted = 0;
PyObject *seq = NULL;
ID **stmp = NULL;
short *ftmp = NULL;
/* check for an optional list of strings */
if( !PyArg_ParseTuple( args, "|O", &seq ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError,
"expected no arguments or a list of strings" ) );
/* if there was a parameter, handle it */
if ( seq != NULL ) {
/* check that parameter IS list of strings */
if ( !PyList_Check ( seq ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError,
"expected a list of strings" ) );
totLinks = PyList_Size ( seq );
for ( i = 0 ; i < totLinks ; ++i ) {
if ( !PyString_Check ( PySequence_GetItem( seq, i ) ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError,
"expected list to contain strings" ) );
}
/*
parameters OK: now look for each script, and delete
its link as we find it (this handles multiple links)
*/
for ( i = 0 ; i < totLinks ; ++i )
{
char *str;
str = PyString_AsString ( PySequence_GetItem( seq, i ) );
for ( j = 0 ; j < slink->totscript ; ++j ) {
if ( slink->scripts[j] && !strcmp ( slink->scripts[j]->name+2, str ) ) {
slink->scripts[j] = NULL;
++deleted;
}
}
}
}
/* if no parameter, then delete all scripts */
else {
deleted = slink->totscript;
}
/*
if not all scripts deleted, create new lists and copy remaining
links to them
*/
if ( slink->totscript > deleted ) {
slink->totscript -= deleted;
stmp = slink->scripts;
slink->scripts =
MEM_mallocN( sizeof( ID * ) * ( slink->totscript ),
"bpySlinkL" );
ftmp = slink->flag;
slink->flag =
MEM_mallocN( sizeof( short * ) * ( slink->totscript ),
"bpySlinkF" );
for ( i = 0, j = 0 ; i < slink->totscript ; ++j ) {
if ( stmp[j] != NULL ) {
memcpy( slink->scripts+i, stmp+j, sizeof( ID * ) );
memcpy( slink->flag+i, ftmp+j, sizeof( short ) );
++i;
}
}
MEM_freeN( stmp );
MEM_freeN( ftmp );
/*EXPP_allqueue (REDRAWBUTSSCRIPT, 0 );*/
slink->actscript = 1;
} else {
/* all scripts deleted, so delete entire list and free memory */
if( slink->scripts )
MEM_freeN( slink->scripts );
if( slink->flag )
MEM_freeN( slink->flag );
slink->scripts = NULL;
slink->flag = NULL;
slink->totscript = slink->actscript = 0;
}
return EXPP_incr_ret( Py_None );
}
PyObject *EXPP_addScriptLink(ScriptLink *slink, PyObject *args, int is_scene)
{
int event = 0, found_txt = 0;
void *stmp = NULL, *ftmp = NULL;
Text *bltxt = G.main->text.first;
char *textname = NULL;
char *eventname = NULL;
/* !scriptlink shouldn't happen ... */
if( !slink ) {
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"internal error: no scriptlink!" );
}
if( !PyArg_ParseTuple( args, "ss", &textname, &eventname ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"expected two strings as arguments" );
while( bltxt ) {
if( !strcmp( bltxt->id.name + 2, textname ) ) {
found_txt = 1;
break;
}
bltxt = bltxt->id.next;
}
if( !found_txt )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"no such Blender Text" );
if( !strcmp( eventname, "FrameChanged" ) )
event = SCRIPT_FRAMECHANGED;
else if( !strcmp( eventname, "Redraw" ) )
event = SCRIPT_REDRAW;
else if( !strcmp( eventname, "Render" ) )
event = SCRIPT_RENDER;
else if( is_scene && !strcmp( eventname, "OnLoad" ) )
event = SCRIPT_ONLOAD;
else if( is_scene && !strcmp( eventname, "OnSave" ) )
event = SCRIPT_ONSAVE;
else
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"invalid event name" );
stmp = slink->scripts;
slink->scripts =
MEM_mallocN( sizeof( ID * ) * ( slink->totscript + 1 ),
"bpySlinkL" );
ftmp = slink->flag;
slink->flag =
MEM_mallocN( sizeof( short * ) * ( slink->totscript + 1 ),
"bpySlinkF" );
if( slink->totscript ) {
memcpy( slink->scripts, stmp,
sizeof( ID * ) * ( slink->totscript ) );
MEM_freeN( stmp );
memcpy( slink->flag, ftmp,
sizeof( short ) * ( slink->totscript ) );
MEM_freeN( ftmp );
}
slink->scripts[slink->totscript] = ( ID * ) bltxt;
slink->flag[slink->totscript] = event;
slink->totscript++;
if( slink->actscript < 1 )
slink->actscript = 1;
return EXPP_incr_ret (Py_None); /* normal exit */
}
View Git Blame Copy Permalink