Index: doc/Particle.py =================================================================== --- doc/Particle.py (revisión: 19871) +++ doc/Particle.py (copia de trabajo) @@ -42,8 +42,35 @@ - OBJECT: Draw object - GROUP: Draw group - BILLBOARD: Draw as billboard +@type PHYSICS: readonly dictionary +@var PHYSICS: Constant dict used for with L{Particle.PHYSICS} + - NONE: No physics + - NEWTONIAN: Use newtonian physics + - KEYED: Use keyed physics + - BOIDS: Use Boids physics +@type INTEGRATOR: readonly dictionary +@var INTEGRATOR: Constant dict used for with L{Particle.INTEGRATOR} + - EULER: Use Euler integrator + - MIDPOINT: Use Midpoint integrator + - RK4: Use RK4 integrator +@type ROTATION: readonly dictionary +@var ROTATION: Constant dict used for with L{Particle.ROTATION} + - NONE: No particle initial rotation + - NOR: Rotate along the normal + - VEL: Rotate affect to velocity + - GLX: Rotate along global X-Axis + - GLY: Rotate along global Y-Axis + - GLZ: Rotate along global Z-Axis + - OBX: Rotate along local X-Axis + - OBY: Rotate along local Y-Axis + - OBZ: Rotate along local Z-Axis +@type ANGULARV: readonly dictionary +@var ANGULARV: Constant dict used for with L{Particle.ANGULARV} + - NONE: No particle angular velocity + - SPIN: Spin particle angular velocity + - RANDOM: Random particle angular velocity @type CHILDTYPE: readonly dictionary -@var CHILDTYPE: Constant dict used for whith L{Particle.CHILDTYPE} +@var CHILDTYPE: Constant dict used for with L{Particle.CHILDTYPE} - NONE: set no children - PARTICLES: set children born from particles - FACES: set children born from faces @@ -135,6 +162,50 @@ @type duplicateObject: Blender Object @ivar drawAs: Get draw type Particle.DRAWAS([ 'NONE' | 'OBJECT' | 'POINT' | ... ]). @type drawAs: int + @ivar physics: Select particle physics type Particle.PHYSICS([ 'BOIDS' | 'KEYED' | 'NEWTONIAN' | 'NONE' ]) + @type physics: int + @ivar integration: Select physics integrator type Particle.INTEGRATOR([ 'RK4' | 'MIDPOINT' | 'EULER' ]) + @type integration: int + @ivar inVelObj: Let the object give the particle a starting speed + @type inVelObj: float + @ivar inVelNor: Let the surface normal give the particle a starting speed + @type inVelNor: float + @ivar inVelRan: Give the starting speed a random variation + @type inVelRan: float + @ivar inVelTan: Let the surface tangent give the particle a starting speed + @type inVelTan: float + @ivar inVelRot: Rotate the surface tangent + @type inVelRot: float + @ivar inVelPart: Let the target particle give the particle a starting speed + @type inVelPart: float + @ivar inVelReact: Let the vector away from the target particles location give the particle a starting speed + @type inVelReact: float + @ivar rotation: Particles initial rotation Particle.ROTATION([ 'OBZ' | 'OBY' | 'OBX' | 'GLZ' | 'GLY' | 'GLX' | 'VEL' | 'NOR' | 'NONE' ]) + @type rotation: int + @ivar rotDyn: Sets rotation to dynamic/constant + @type rotDyn: int + @ivar rotRand: Randomize rotation + @type rotRand: float + @ivar rotPhase: Initial rotation phase + @type rotPhase: float + @ivar rotPhaseR: Randomize rotation phase + @type rotPhaseR: float + @ivar rotAnV: Select particle angular velocity mode Particle.ANGULARV([ 'RANDOM' | 'SPIN' | 'NONE' ]) + @type rotAnV: int + @ivar rotAnVAm: Angular velocity amount + @type rotAnVAm: float + @ivar glAccX: Specify a constant acceleration along the X-axis + @type glAccX: float + @ivar glAccY: Specify a constant acceleration along the Y-axis + @type glAccY: float + @ivar glAccZ: Specify a constant acceleration along the Z-axis + @type glAccZ: float + @ivar glDrag: Specify the amount of air-drag + @type glDrag: float + @ivar glBrown: Specify the amount of brownian motion + @type glBrown: float + @ivar glDamp: Specify the amount of damping + @type glDamp: float @ivar childAmount: The total number of children @type childAmount: int @ivar childType: Type of childrens ( Particle.CHILDTYPE[ 'FACES' | 'PARTICLES' | 'NONE' ] ) Index: Particle.c =================================================================== --- Particle.c (revisión: 20153) +++ Particle.c (copia de trabajo) @@ -133,6 +133,50 @@ static PyObject *Part_getRenderStep( BPy_PartSys * self ); static PyObject *Part_getDupOb( BPy_PartSys * self ); static PyObject *Part_getDrawAs( BPy_PartSys * self ); +static int Part_setPhysType( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getPhysType( BPy_PartSys * self ); +static int Part_setIntegrator( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getIntegrator( BPy_PartSys * self ); +static int Part_setIniVelObject( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getIniVelObject( BPy_PartSys * self ); +static int Part_setIniVelNormal( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getIniVelNormal( BPy_PartSys * self ); +static int Part_setIniVelRandom( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getIniVelRandom( BPy_PartSys * self ); +static int Part_setIniVelTan( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getIniVelTan( BPy_PartSys * self ); +static int Part_setIniVelRot( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getIniVelRot( BPy_PartSys * self ); +static int Part_setIniVelPart( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getIniVelPart( BPy_PartSys * self ); +static int Part_setIniVelReact( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getIniVelReact( BPy_PartSys * self ); +static int Part_setRotDynamic( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getRotDynamic( BPy_PartSys * self ); +static int Part_setRotation( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getRotation( BPy_PartSys * self ); +static int Part_setRotRandom( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getRotRandom( BPy_PartSys * self ); +static int Part_setRotPhase( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getRotPhase( BPy_PartSys * self ); +static int Part_setRotPhaseR( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getRotPhaseR( BPy_PartSys * self ); +static int Part_setRotAngularV( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getRotAngularV( BPy_PartSys * self ); +static int Part_setRotAngularVAm( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getRotAngularVAm( BPy_PartSys * self ); +static int Part_setGlobAccX( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getGlobAccX( BPy_PartSys * self ); +static int Part_setGlobAccY( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getGlobAccY( BPy_PartSys * self ); +static int Part_setGlobAccZ( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getGlobAccZ( BPy_PartSys * self ); +static int Part_setGlobDrag( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getGlobDrag( BPy_PartSys * self ); +static int Part_setGlobBrown( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getGlobBrown( BPy_PartSys * self ); +static int Part_setGlobDamp( BPy_PartSys * self, PyObject * args ); +static PyObject *Part_getGlobDamp( BPy_PartSys * self ); static PyObject *Part_GetAge( BPy_PartSys * self, PyObject * args ); static int Part_setChildAmount( BPy_PartSys * self, PyObject * args ); static PyObject *Part_getChildAmount( BPy_PartSys * self ); @@ -366,6 +410,95 @@ (getter)Part_getDrawAs, NULL, "Get draw type Particle.DRAWAS([ 'NONE' | 'OBJECT' | 'POINT' | ... ] )", NULL}, +/* Newtonian Physics */ + {"physics", + (getter)Part_getPhysType, (setter)Part_setPhysType, + "Select particle physics type Particle.PHYSICS([ 'BOIDS' | 'KEYED' | 'NEWTONIAN' | 'NONE' ])", + NULL}, + {"integration", + (getter)Part_getIntegrator, (setter)Part_setIntegrator, + "Select physics integrator type Particle.INTEGRATOR([ 'RK4' | 'MIDPOINT' | 'EULER' ])", + NULL}, + {"inVelObj", + (getter)Part_getIniVelObject, (setter)Part_setIniVelObject, + "Let the object give the particle a starting speed", + NULL}, + {"inVelNor", + (getter)Part_getIniVelNormal, (setter)Part_setIniVelNormal, + "Let the surface normal give the particle a starting speed", + NULL}, + {"inVelRan", + (getter)Part_getIniVelRandom, (setter)Part_setIniVelRandom, + "Give the starting speed a random variation", + NULL}, + {"inVelTan", + (getter)Part_getIniVelTan, (setter)Part_setIniVelTan, + "Let the surface tangent give the particle a starting speed", + NULL}, + {"inVelRot", + (getter)Part_getIniVelRot, (setter)Part_setIniVelRot, + "Rotate the surface tangent", + NULL}, + {"inVelPart", + (getter)Part_getIniVelPart, (setter)Part_setIniVelPart, + "Let the target particle give the particle a starting speed", + NULL}, + {"inVelReact", + (getter)Part_getIniVelReact, (setter)Part_setIniVelReact, + "Let the vector away from the target particles location give the particle a starting speed", + NULL}, + {"rotation", + (getter)Part_getRotation, (setter)Part_setRotation, + "Particles initial rotation Particle.ROTATION([ 'OBZ' | 'OBY' | 'OBX' | 'GLZ' | 'GLY' | 'GLX' | 'VEL' | 'NOR' | 'NONE' ])", + NULL}, + {"rotDyn", + (getter)Part_getRotDynamic, (setter)Part_setRotDynamic, + "Sets rotation to dynamic/constant", + NULL}, + {"rotRand", + (getter)Part_getRotRandom, (setter)Part_setRotRandom, + "Randomize rotation", + NULL}, + {"rotPhase", + (getter)Part_getRotPhase, (setter)Part_setRotPhase, + "Initial rotation phase", + NULL}, + {"rotPhaseR", + (getter)Part_getRotPhaseR, (setter)Part_setRotPhaseR, + "Randomize rotation phase", + NULL}, + {"rotAnV", + (getter)Part_getRotAngularV, (setter)Part_setRotAngularV, + "Select particle angular velocity mode Particle.ANGULARV([ 'RANDOM' | 'SPIN' | 'NONE' ])", + NULL}, + {"rotAnVAm", + (getter)Part_getRotAngularVAm, (setter)Part_setRotAngularVAm, + "Angular velocity amount", + NULL}, + {"glAccX", + (getter)Part_getGlobAccX, (setter)Part_setGlobAccX, + "Specify a constant acceleration along the X-axis", + NULL}, + {"glAccY", + (getter)Part_getGlobAccY, (setter)Part_setGlobAccY, + "Specify a constant acceleration along the Y-axis", + NULL}, + {"glAccZ", + (getter)Part_getGlobAccZ, (setter)Part_setGlobAccZ, + "Specify a constant acceleration along the Z-axis", + NULL}, + {"glDrag", + (getter)Part_getGlobDrag, (setter)Part_setGlobDrag, + "Specify the amount of air-drag", + NULL}, + {"glBrown", + (getter)Part_getGlobBrown, (setter)Part_setGlobBrown, + "Specify the amount of brownian motion", + NULL}, + {"glDamp", + (getter)Part_getGlobDamp, (setter)Part_setGlobDamp, + "Specify the amount of damping", + NULL}, /* Children */ {"childAmount", (getter)Part_getChildAmount, (setter)Part_setChildAmount, @@ -859,7 +992,96 @@ return ReactOn; } +/* create the Blender.Particle.Physics constant dict */ +static PyObject *Particle_PhysicsDict( void ) +{ + PyObject *Physics = PyConstant_New( ); + + if( Physics ) { + BPy_constant *c = ( BPy_constant * ) Physics; + + PyConstant_Insert( c, "BOIDS", + PyInt_FromLong( 3 ) ); + PyConstant_Insert( c, "KEYED", + PyInt_FromLong( 2 ) ); + PyConstant_Insert( c, "NEWTONIAN", + PyInt_FromLong( 1 ) ); + PyConstant_Insert( c, "NONE", + PyInt_FromLong( 0 ) ); + } + return Physics; +} + +/* create the Blender.Particle.Integrator constant dict */ + +static PyObject *Particle_IntegratorDict( void ) +{ + PyObject *Integrator = PyConstant_New( ); + + if( Integrator ) { + BPy_constant *c = ( BPy_constant * ) Integrator; + + PyConstant_Insert( c, "EULER", + PyInt_FromLong( 2 ) ); + PyConstant_Insert( c, "MIDPOINT", + PyInt_FromLong( 1 ) ); + PyConstant_Insert( c, "EULER", + PyInt_FromLong( 0 ) ); + } + return Integrator; +} + +/* create the Blender.Particle.Rotation constant dict */ + +static PyObject *Particle_RotationDict( void ) +{ + PyObject *Rotation = PyConstant_New( ); + + if( Rotation ) { + BPy_constant *c = ( BPy_constant * ) Rotation; + + PyConstant_Insert( c, "OBZ", + PyInt_FromLong( 8 ) ); + PyConstant_Insert( c, "OBY", + PyInt_FromLong( 7 ) ); + PyConstant_Insert( c, "OBX", + PyInt_FromLong( 6 ) ); + PyConstant_Insert( c, "GLZ", + PyInt_FromLong( 5 ) ); + PyConstant_Insert( c, "GLY", + PyInt_FromLong( 4 ) ); + PyConstant_Insert( c, "GLX", + PyInt_FromLong( 3 ) ); + PyConstant_Insert( c, "VEL", + PyInt_FromLong( 2 ) ); + PyConstant_Insert( c, "NOR", + PyInt_FromLong( 1 ) ); + PyConstant_Insert( c, "NONE", + PyInt_FromLong( 0 ) ); + } + return Rotation; +} + +/* create the Blender.Particle.AngularV constant dict */ + +static PyObject *Particle_AngularVDict( void ) +{ + PyObject *AngularV = PyConstant_New( ); + + if( AngularV ) { + BPy_constant *c = ( BPy_constant * ) AngularV; + + PyConstant_Insert( c, "RANDOM", + PyInt_FromLong( 2 ) ); + PyConstant_Insert( c, "SPIN", + PyInt_FromLong( 1 ) ); + PyConstant_Insert( c, "NONE", + PyInt_FromLong( 0 ) ); + } + return AngularV; +} + /* create the Blender.Particle.ChildType constant dict */ static PyObject *Particle_ChildTypeDict( void ) @@ -967,6 +1189,10 @@ PyObject *EmitFrom; PyObject *Dist; PyObject *DrawAs; + PyObject *Physics; + PyObject *Integrator; + PyObject *Rotation; + PyObject *AngularV; PyObject *ChildTypes; PyObject *ChildKinks; PyObject *ChildKinkAxes; @@ -980,6 +1206,10 @@ EmitFrom = Particle_EmitFrom(); DrawAs = Particle_DrawAs(); Dist = Particle_DistrDict(); + Physics = Particle_PhysicsDict(); + Integrator = Particle_IntegratorDict(); + Rotation = Particle_RotationDict(); + AngularV = Particle_AngularVDict(); ChildTypes = Particle_ChildTypeDict(); ChildKinks = Particle_ChildKinkDict(); ChildKinkAxes = Particle_ChildKinkAxisDict(); @@ -997,6 +1227,14 @@ PyModule_AddObject( submodule, "DISTRIBUTION", Dist ); if( DrawAs ) PyModule_AddObject( submodule, "DRAWAS", DrawAs ); + if( Physics ) + PyModule_AddObject( submodule, "PHYSICS", Physics ); + if( Integrator ) + PyModule_AddObject( submodule, "INTEGRATOR", Integrator ); + if( Rotation ) + PyModule_AddObject( submodule, "ROTATION", Rotation ); + if( AngularV ) + PyModule_AddObject( submodule, "ANGULARV", AngularV ); if( ChildTypes ) PyModule_AddObject( submodule, "CHILDTYPE", ChildTypes ); if( ChildKinks ) @@ -2202,6 +2440,346 @@ return PyInt_FromLong( (long)( self->psys->part->draw_as ) ); } +static int Part_setPhysType( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setIValueRange( args, &self->psys->part->phystype, + 0, 3, 'h' ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getPhysType( BPy_PartSys * self ) +{ + return PyInt_FromLong( (short)( self->psys->part->phystype ) ); +} + +static int Part_setIntegrator( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setIValueRange( args, &self->psys->part->integrator, + 0, 2, 'h' ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getIntegrator( BPy_PartSys * self ) +{ + return PyInt_FromLong( (short)( self->psys->part->integrator ) ); +} + +static int Part_setIniVelObject( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->obfac, + -1.0, 1.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getIniVelObject( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->obfac )) ); +} + +static int Part_setIniVelNormal( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->normfac, + -200.0, 200.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getIniVelNormal( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->normfac )) ); +} + +static int Part_setIniVelRandom( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->randfac, + 0.0, 200.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getIniVelRandom( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->randfac )) ); +} + +static int Part_setIniVelTan( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->tanfac, + -200.0, 200.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getIniVelTan( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->tanfac )) ); +} + +static int Part_setIniVelRot( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->tanphase, + -1.0, 1.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getIniVelRot( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->tanphase )) ); +} + +static int Part_setIniVelPart( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->partfac, + -10.0, 10.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getIniVelPart( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->partfac )) ); +} + +static int Part_setIniVelReact( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->reactfac, + -10.0, 10.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getIniVelReact( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->reactfac )) ); +} + +static int Part_setRotation( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setIValueRange( args, &self->psys->part->rotmode, + 0, 8, 'h' ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getRotation( BPy_PartSys * self ) +{ + return PyInt_FromLong( (short)( self->psys->part->rotmode ) ); +} + +static int Part_setRotDynamic( BPy_PartSys * self, PyObject * args ) +{ + int number; + + if( !PyInt_Check( args ) ) + return EXPP_ReturnIntError( PyExc_TypeError, "expected int argument" ); + + number = PyInt_AS_LONG( args ); + + if (number){ + self->psys->part->flag |= PART_ROT_DYN; + }else{ + self->psys->part->flag &= ~PART_ROT_DYN; + } + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return 0; +} + +static PyObject *Part_getRotDynamic( BPy_PartSys * self ) +{ + return PyInt_FromLong( ((long)( self->psys->part->flag & PART_ROT_DYN )) > 0 ); +} + +static int Part_setRotRandom( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->randrotfac, + 0.0, 1.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getRotRandom( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->randrotfac )) ); +} + +static int Part_setRotPhase( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->phasefac, + -1.0, 1.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getRotPhase( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->phasefac )) ); +} + +static int Part_setRotPhaseR( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->randphasefac, + 0.0, 1.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getRotPhaseR( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->randphasefac )) ); +} + +static int Part_setRotAngularV( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setIValueRange( args, &self->psys->part->avemode, + 0, 2, 'h' ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getRotAngularV( BPy_PartSys * self ) +{ + return PyInt_FromLong( ((int)( self->psys->part->avemode )) ); +} + +static int Part_setRotAngularVAm( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->avefac, + -200.0, 200.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getRotAngularVAm( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->avefac )) ); +} + +static int Part_setGlobAccX( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->acc[0], + -200.0, 200.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getGlobAccX( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->acc[0] )) ); +} + +static int Part_setGlobAccY( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->acc[1], + -200.0, 200.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getGlobAccY( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->acc[1] )) ); +} + +static int Part_setGlobAccZ( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->acc[2], + -200.0, 200.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getGlobAccZ( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->acc[2] )) ); +} + +static int Part_setGlobDrag( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->dragfac, + 0.0, 1.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getGlobDrag( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->dragfac )) ); +} + +static int Part_setGlobBrown( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->brownfac, + 0.0, 200.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getGlobBrown( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->brownfac )) ); +} + +static int Part_setGlobDamp( BPy_PartSys * self, PyObject * args ) +{ + int res = EXPP_setFloatRange( args, &self->psys->part->dampfac, + 0.0, 1.0 ); + + psys_flush_settings( self->psys->part, PSYS_ALLOC, 1 ); + + return res; +} + +static PyObject *Part_getGlobDamp( BPy_PartSys * self ) +{ + return PyFloat_FromDouble( ((float)( self->psys->part->dampfac )) ); +} + static int Part_setChildAmount( BPy_PartSys * self, PyObject * args ) { int res = EXPP_setIValueRange( args, &self->psys->part->child_nbr,