← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/blender/gutsy-security

« back to all changes in this revision

Viewing changes to source/blender/python/api2_2x/Particle.c

  • Committer: Bazaar Package Importer
  • Author(s): Florian Ernst
  • Date: 2005-11-06 12:40:03 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051106124003-3pgs7tcg5rox96xg
Tags: 2.37a-1.1
http://bugs.debian.org/333958
* Non-maintainer upload.
* Split out parts of 01_SConstruct_debian.dpatch again: root_build_dir
  really needs to get adjusted before the clean target runs - closes: #333958,
  see #288882 for reference

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/python/api2_2x/Particle.c
1
1
/*
 
2
 * $Id: Particle.c,v 1.8 2005/03/09 19:45:55 lukep Exp $
2
3
 *
3
4
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
4
5
 *
33
34
#include "Effect.h"
34
35
 
35
36
/*****************************************************************************/
36
 
/* Python BPy_Particle methods table:                                          */
 
37
/* Python BPy_Particle methods table:                                        */
37
38
/*****************************************************************************/
38
39
static PyMethodDef BPy_Particle_methods[] = {
39
 
        {"getType", (PyCFunction)Effect_getType,
40
 
         METH_NOARGS,"() - Return Effect type"},
41
 
  {"setType", (PyCFunction)Effect_setType, 
42
 
   METH_VARARGS,"() - Set Effect type"},
43
 
  {"getFlag", (PyCFunction)Effect_getFlag, 
44
 
   METH_NOARGS,"() - Return Effect flag"},
45
 
  {"setFlag", (PyCFunction)Effect_setFlag, 
46
 
   METH_VARARGS,"() - Set Effect flag"},
47
 
  {"getStartTime",(PyCFunction)Particle_getSta,
48
 
         METH_NOARGS,"()-Return particle start time"},
49
 
  {"setStartTime",(PyCFunction)Particle_setSta, METH_VARARGS,
 
40
        {"getType", ( PyCFunction ) Effect_getType,
 
41
         METH_NOARGS, "() - Return Effect type"},
 
42
        {"setType", ( PyCFunction ) Effect_setType,
 
43
         METH_VARARGS, "() - Set Effect type"},
 
44
        {"getFlag", ( PyCFunction ) Effect_getFlag,
 
45
         METH_NOARGS, "() - Return Effect flag"},
 
46
        {"setFlag", ( PyCFunction ) Effect_setFlag,
 
47
         METH_VARARGS, "() - Set Effect flag"},
 
48
        {"getStartTime", ( PyCFunction ) Particle_getSta,
 
49
         METH_NOARGS, "()-Return particle start time"},
 
50
        {"setStartTime", ( PyCFunction ) Particle_setSta, METH_VARARGS,
50
51
         "()- Sets particle start time"},
51
 
  {"getEndTime",(PyCFunction)Particle_getEnd,
52
 
         METH_NOARGS,"()-Return particle end time"},
53
 
  {"setEndTime",(PyCFunction)Particle_setEnd, METH_VARARGS,
 
52
        {"getEndTime", ( PyCFunction ) Particle_getEnd,
 
53
         METH_NOARGS, "()-Return particle end time"},
 
54
        {"setEndTime", ( PyCFunction ) Particle_setEnd, METH_VARARGS,
54
55
         "()- Sets particle end time"},
55
 
  {"getLifetime",(PyCFunction)Particle_getLifetime,
56
 
         METH_NOARGS,"()-Return particle life time"},
57
 
  {"setLifetime",(PyCFunction)Particle_setLifetime, METH_VARARGS,
58
 
         "()- Sets particle life time "},
59
 
  {"getNormfac",(PyCFunction)Particle_getNormfac,
60
 
         METH_NOARGS,"()-Return particle life time"},
61
 
  {"setNormfac",(PyCFunction)Particle_setNormfac, METH_VARARGS,
62
 
         "()- Sets particle life time "},
63
 
  {"getObfac",(PyCFunction)Particle_getObfac,
64
 
         METH_NOARGS,"()-Return particle life time"},
65
 
  {"setObfac",(PyCFunction)Particle_setObfac, METH_VARARGS,
66
 
         "()- Sets particle life time "},
67
 
  {"getRandfac",(PyCFunction)Particle_getRandfac,
68
 
         METH_NOARGS,"()-Return particle life time"},
69
 
  {"setRandfac",(PyCFunction)Particle_setRandfac, METH_VARARGS,
70
 
         "()- Sets particle life time "},
71
 
  {"getTexfac",(PyCFunction)Particle_getTexfac,
72
 
         METH_NOARGS,"()-Return particle life time"},
73
 
  {"setTexfac",(PyCFunction)Particle_setTexfac, METH_VARARGS,
74
 
         "()- Sets particle life time "},
75
 
  {"getRandlife",(PyCFunction)Particle_getRandlife,
76
 
         METH_NOARGS,"()-Return particle life time"},
77
 
  {"setRandlife",(PyCFunction)Particle_setRandlife, METH_VARARGS,
78
 
         "()- Sets particle life time "},
79
 
  {"getNabla",(PyCFunction)Particle_getNabla,
80
 
         METH_NOARGS,"()-Return particle life time"},
81
 
  {"setNabla",(PyCFunction)Particle_setNabla, METH_VARARGS,
82
 
         "()- Sets particle life time "},
83
 
  {"getVectsize",(PyCFunction)Particle_getVectsize,
84
 
         METH_NOARGS,"()-Return particle life time"},
85
 
  {"setVectsize",(PyCFunction)Particle_setVectsize, METH_VARARGS,
86
 
         "()- Sets particle life time "},
87
 
  {"getTotpart",(PyCFunction)Particle_getTotpart,
88
 
         METH_NOARGS,"()-Return particle life time"},
89
 
  {"setTotpart",(PyCFunction)Particle_setTotpart, METH_VARARGS,
90
 
         "()- Sets particle life time "},
91
 
  {"getTotkey",(PyCFunction)Particle_getTotkey,
92
 
         METH_NOARGS,"()-Return particle life time"},
93
 
  {"setTotkey",(PyCFunction)Particle_setTotkey, METH_VARARGS,
94
 
         "()- Sets particle life time "},
95
 
  {"getSeed",(PyCFunction)Particle_getSeed,
96
 
         METH_NOARGS,"()-Return particle life time"},
97
 
  {"setSeed",(PyCFunction)Particle_setSeed, METH_VARARGS,
98
 
         "()- Sets particle life time "},
99
 
  {"getForce",(PyCFunction)Particle_getForce,
100
 
         METH_NOARGS,"()-Return particle life time"},
101
 
  {"setForce",(PyCFunction)Particle_setForce, METH_VARARGS,
102
 
         "()- Sets particle life time "},
103
 
  {"getMult",(PyCFunction)Particle_getMult,
104
 
         METH_NOARGS,"()-Return particle life time"},
105
 
  {"setMult",(PyCFunction)Particle_setMult, METH_VARARGS,
106
 
         "()- Sets particle life time "},
107
 
  {"getLife",(PyCFunction)Particle_getLife,
108
 
         METH_NOARGS,"()-Return particle life time"},
109
 
  {"setLife",(PyCFunction)Particle_setLife, METH_VARARGS,
110
 
         "()- Sets particle life time "},
111
 
  {"getMat",(PyCFunction)Particle_getMat,
112
 
         METH_NOARGS,"()-Return particle life time"},
113
 
  {"setMat",(PyCFunction)Particle_setMat, METH_VARARGS,
114
 
         "()- Sets particle life time "},
115
 
  {"getChild",(PyCFunction)Particle_getChild,
116
 
         METH_NOARGS,"()-Return particle life time"},
117
 
  {"setChild",(PyCFunction)Particle_setChild, METH_VARARGS,
118
 
         "()- Sets particle life time "},
119
 
  {"getDefvec",(PyCFunction)Particle_getDefvec,
120
 
         METH_NOARGS,"()-Return particle life time"},
121
 
  {"setDefvec",(PyCFunction)Particle_setDefvec, METH_VARARGS,
122
 
         "()- Sets particle life time "},
123
 
        {0}
 
56
        {"getLifetime", ( PyCFunction ) Particle_getLifetime,
 
57
         METH_NOARGS, "()-Return particle life time"},
 
58
        {"setLifetime", ( PyCFunction ) Particle_setLifetime, METH_VARARGS,
 
59
         "()- Sets particle life time "},
 
60
        {"getNormfac", ( PyCFunction ) Particle_getNormfac,
 
61
         METH_NOARGS, "()-Return particle life time"},
 
62
        {"setNormfac", ( PyCFunction ) Particle_setNormfac, METH_VARARGS,
 
63
         "()- Sets particle life time "},
 
64
        {"getObfac", ( PyCFunction ) Particle_getObfac,
 
65
         METH_NOARGS, "()-Return particle life time"},
 
66
        {"setObfac", ( PyCFunction ) Particle_setObfac, METH_VARARGS,
 
67
         "()- Sets particle life time "},
 
68
        {"getRandfac", ( PyCFunction ) Particle_getRandfac,
 
69
         METH_NOARGS, "()-Return particle life time"},
 
70
        {"setRandfac", ( PyCFunction ) Particle_setRandfac, METH_VARARGS,
 
71
         "()- Sets particle life time "},
 
72
        {"getTexfac", ( PyCFunction ) Particle_getTexfac,
 
73
         METH_NOARGS, "()-Return particle life time"},
 
74
        {"setTexfac", ( PyCFunction ) Particle_setTexfac, METH_VARARGS,
 
75
         "()- Sets particle life time "},
 
76
        {"getRandlife", ( PyCFunction ) Particle_getRandlife,
 
77
         METH_NOARGS, "()-Return particle life time"},
 
78
        {"setRandlife", ( PyCFunction ) Particle_setRandlife, METH_VARARGS,
 
79
         "()- Sets particle life time "},
 
80
        {"getNabla", ( PyCFunction ) Particle_getNabla,
 
81
         METH_NOARGS, "()-Return particle life time"},
 
82
        {"setNabla", ( PyCFunction ) Particle_setNabla, METH_VARARGS,
 
83
         "()- Sets particle life time "},
 
84
        {"getVectsize", ( PyCFunction ) Particle_getVectsize,
 
85
         METH_NOARGS, "()-Return particle life time"},
 
86
        {"setVectsize", ( PyCFunction ) Particle_setVectsize, METH_VARARGS,
 
87
         "()- Sets particle life time "},
 
88
        {"getTotpart", ( PyCFunction ) Particle_getTotpart,
 
89
         METH_NOARGS, "()-Return particle life time"},
 
90
        {"setTotpart", ( PyCFunction ) Particle_setTotpart, METH_VARARGS,
 
91
         "()- Sets particle life time "},
 
92
        {"getTotkey", ( PyCFunction ) Particle_getTotkey,
 
93
         METH_NOARGS, "()-Return particle life time"},
 
94
        {"setTotkey", ( PyCFunction ) Particle_setTotkey, METH_VARARGS,
 
95
         "()- Sets particle life time "},
 
96
        {"getSeed", ( PyCFunction ) Particle_getSeed,
 
97
         METH_NOARGS, "()-Return particle life time"},
 
98
        {"setSeed", ( PyCFunction ) Particle_setSeed, METH_VARARGS,
 
99
         "()- Sets particle life time "},
 
100
        {"getForce", ( PyCFunction ) Particle_getForce,
 
101
         METH_NOARGS, "()-Return particle life time"},
 
102
        {"setForce", ( PyCFunction ) Particle_setForce, METH_VARARGS,
 
103
         "()- Sets particle life time "},
 
104
        {"getMult", ( PyCFunction ) Particle_getMult,
 
105
         METH_NOARGS, "()-Return particle life time"},
 
106
        {"setMult", ( PyCFunction ) Particle_setMult, METH_VARARGS,
 
107
         "()- Sets particle life time "},
 
108
        {"getLife", ( PyCFunction ) Particle_getLife,
 
109
         METH_NOARGS, "()-Return particle life time"},
 
110
        {"setLife", ( PyCFunction ) Particle_setLife, METH_VARARGS,
 
111
         "()- Sets particle life time "},
 
112
        {"getMat", ( PyCFunction ) Particle_getMat,
 
113
         METH_NOARGS, "()-Return particle life time"},
 
114
        {"setMat", ( PyCFunction ) Particle_setMat, METH_VARARGS,
 
115
         "()- Sets particle life time "},
 
116
        {"getChild", ( PyCFunction ) Particle_getChild,
 
117
         METH_NOARGS, "()-Return particle life time"},
 
118
        {"setChild", ( PyCFunction ) Particle_setChild, METH_VARARGS,
 
119
         "()- Sets particle life time "},
 
120
        {"getDefvec", ( PyCFunction ) Particle_getDefvec,
 
121
         METH_NOARGS, "()-Return particle life time"},
 
122
        {"setDefvec", ( PyCFunction ) Particle_setDefvec, METH_VARARGS,
 
123
         "()- Sets particle life time "},
 
124
        {NULL, NULL, 0, NULL}
124
125
};
125
126
 
 
127
/**************** prototypes ********************/
 
128
PyObject *Particle_Init( void );
 
129
 
126
130
 
127
131
/*****************************************************************************/
128
132
/* Python Particle_Type structure definition:                                */
129
133
/*****************************************************************************/
130
134
 
131
 
PyTypeObject Particle_Type =
132
 
{
133
 
  PyObject_HEAD_INIT(NULL)
134
 
  0,                                   
135
 
  "Particle",                              
136
 
  sizeof (BPy_Particle),                     
137
 
  0,                                    
 
135
PyTypeObject Particle_Type = {
 
136
        PyObject_HEAD_INIT( NULL )
 
137
                0,
 
138
        "Particle",
 
139
        sizeof( BPy_Particle ),
 
140
        0,
138
141
 
139
 
  (destructor)ParticleDeAlloc,           
140
 
  0,               
141
 
  (getattrfunc)ParticleGetAttr,           
142
 
  (setattrfunc)ParticleSetAttr,        
143
 
  0,                                     
144
 
  (reprfunc)ParticleRepr,                  
145
 
  0,                                   
146
 
  0,                                    
147
 
  0,                                    
148
 
  0,                                    
149
 
  0,0,0,0,0,0,
150
 
  0,                                   
151
 
  0,0,0,0,0,0,
152
 
  BPy_Particle_methods,                    
153
 
  0,                                   
 
142
        ( destructor ) ParticleDeAlloc,
 
143
        0,
 
144
        ( getattrfunc ) ParticleGetAttr,
 
145
        ( setattrfunc ) ParticleSetAttr,
 
146
        0,
 
147
        ( reprfunc ) ParticleRepr,
 
148
        0,
 
149
        0,
 
150
        0,
 
151
        0,
 
152
        0, 0, 0, 0, 0, 0,
 
153
        0,
 
154
        0, 0, 0, 0, 0, 0,
 
155
        BPy_Particle_methods,
 
156
        0,
154
157
};
155
158
/*****************************************************************************/
156
159
/* The following string definitions are used for documentation strings.      */
163
166
        New(opt name) : creates a new part object with the given name (optional)\n\
164
167
        Get(name) : retreives a particle  with the given name (mandatory)\n\
165
168
        get(name) : same as Get. Kept for compatibility reasons";
166
 
char M_Particle_New_doc[] ="";
167
 
char M_Particle_Get_doc[] ="xxx";
 
169
char M_Particle_New_doc[] = "";
 
170
char M_Particle_Get_doc[] = "xxx";
168
171
/*****************************************************************************/
169
172
/* Python method structure definition for Blender.Particle module:           */
170
173
/*****************************************************************************/
171
174
struct PyMethodDef M_Particle_methods[] = {
172
 
  {"New",(PyCFunction)M_Particle_New, METH_VARARGS,M_Particle_New_doc},
173
 
  {"Get",         M_Particle_Get,         METH_VARARGS, M_Particle_Get_doc},
174
 
  {"get",         M_Particle_Get,         METH_VARARGS, M_Particle_Get_doc},
175
 
  {NULL, NULL, 0, NULL}
 
175
        {"New", ( PyCFunction ) M_Particle_New, METH_VARARGS,
 
176
         M_Particle_New_doc},
 
177
        {"Get", M_Particle_Get, METH_VARARGS, M_Particle_Get_doc},
 
178
        {"get", M_Particle_Get, METH_VARARGS, M_Particle_Get_doc},
 
179
        {NULL, NULL, 0, NULL}
176
180
};
177
181
 
178
182
/*****************************************************************************/
179
183
/* Function:              M_Particle_New                                     */
180
184
/* Python equivalent:     Blender.Effect.Particle.New                        */
181
185
/*****************************************************************************/
182
 
PyObject *M_Particle_New(PyObject *self, PyObject *args)
 
186
PyObject *M_Particle_New( PyObject * self, PyObject * args )
183
187
{
184
 
        int type =   EFF_PARTICLE;
185
 
  BPy_Effect    *pyeffect; 
186
 
  Effect      *bleffect = 0;
187
 
  
188
 
 
189
 
  bleffect = add_effect(type);
190
 
  if (bleffect == NULL) 
191
 
    return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
192
 
                                                                                                                                         "couldn't create Effect Data in Blender"));
193
 
 
194
 
  pyeffect = (BPy_Effect *)PyObject_NEW(BPy_Effect, &Effect_Type);
195
 
 
196
 
     
197
 
  if (pyeffect == NULL) return (EXPP_ReturnPyObjError (PyExc_MemoryError,
198
 
                                                                                                                                                                                                                         "couldn't create Effect Data object"));
199
 
 
200
 
  pyeffect->effect = bleffect; 
201
 
 
202
 
  return (PyObject *)pyeffect;
203
 
  return 0;
 
188
        int type = EFF_PARTICLE;
 
189
        BPy_Effect *pyeffect;
 
190
        Effect *bleffect = 0;
 
191
 
 
192
 
 
193
        bleffect = add_effect( type );
 
194
        if( bleffect == NULL )
 
195
                return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
 
196
                                                "couldn't create Effect Data in Blender" ) );
 
197
 
 
198
        pyeffect = ( BPy_Effect * ) PyObject_NEW( BPy_Effect, &Effect_Type );
 
199
 
 
200
 
 
201
        if( pyeffect == NULL )
 
202
                return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
 
203
                                                "couldn't create Effect Data object" ) );
 
204
 
 
205
        pyeffect->effect = bleffect;
 
206
 
 
207
        return ( PyObject * ) pyeffect;
 
208
        return 0;
204
209
}
205
210
 
206
211
/*****************************************************************************/
207
212
/* Function:              M_Particle_Get                                     */
208
213
/* Python equivalent:     Blender.Effect.Particle.Get                        */
209
214
/*****************************************************************************/
210
 
PyObject *M_Particle_Get(PyObject *self, PyObject *args)
 
215
PyObject *M_Particle_Get( PyObject * self, PyObject * args )
211
216
{
212
 
  /*arguments : string object name
213
 
    int : position of effect in the obj's effect list  */
214
 
  char     *name = 0;
215
 
  Object   *object_iter;
216
 
  Effect *eff;
217
 
  BPy_Particle *wanted_eff;
218
 
  int num,i;
219
 
  if (!PyArg_ParseTuple(args, "si", &name, &num ))
220
 
    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
221
 
                                                                                                                                 "expected string int argument"));
222
 
 
223
 
  object_iter = G.main->object.first;
224
 
  if (!object_iter)return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
225
 
                                                                                                                                                                                                "Scene contains no object"));
226
 
 
227
 
  while (object_iter)
228
 
    {
229
 
      if (strcmp(name,object_iter->id.name+2))
230
 
                                {
231
 
                                        object_iter = object_iter->id.next;
 
217
        /*arguments : string object name
 
218
           int : position of effect in the obj's effect list  */
 
219
        char *name = 0;
 
220
        Object *object_iter;
 
221
        Effect *eff;
 
222
        BPy_Particle *wanted_eff;
 
223
        int num, i;
 
224
        if( !PyArg_ParseTuple( args, "si", &name, &num ) )
 
225
                return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 
226
                                                "expected string int argument" ) );
 
227
 
 
228
        object_iter = G.main->object.first;
 
229
        if( !object_iter )
 
230
                return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 
231
                                                "Scene contains no object" ) );
 
232
 
 
233
        while( object_iter ) {
 
234
                if( strcmp( name, object_iter->id.name + 2 ) ) {
 
235
                        object_iter = object_iter->id.next;
 
236
                        continue;
 
237
                }
 
238
 
 
239
 
 
240
                if( object_iter->effect.first != NULL ) {
 
241
                        eff = object_iter->effect.first;
 
242
                        for( i = 0; i < num; i++ ) {
 
243
                                if( eff->type != EFF_PARTICLE )
232
244
                                        continue;
233
 
                                }
234
 
 
235
 
      
236
 
      if (object_iter->effect.first != NULL)
237
 
                                {
238
 
                                        eff = object_iter->effect.first;
239
 
                                        for(i = 0;i<num;i++)
240
 
                                                {
241
 
                                                        if (eff->type != EFF_PARTICLE)continue;
242
 
                                                        eff = eff->next;
243
 
                                                        if (!eff)
244
 
                                                                return(EXPP_ReturnPyObjError(PyExc_AttributeError,"bject"));
245
 
                                                }
246
 
                                        wanted_eff = (BPy_Particle *)PyObject_NEW(BPy_Particle, &Particle_Type);
247
 
                                        wanted_eff->particle = eff;
248
 
                                        return (PyObject*)wanted_eff;  
249
 
                                }
250
 
      object_iter = object_iter->id.next;
251
 
    }
252
 
  Py_INCREF(Py_None);
253
 
  return Py_None;
 
245
                                eff = eff->next;
 
246
                                if( !eff )
 
247
                                        return ( EXPP_ReturnPyObjError
 
248
                                                 ( PyExc_AttributeError,
 
249
                                                   "bject" ) );
 
250
                        }
 
251
                        wanted_eff =
 
252
                                ( BPy_Particle * ) PyObject_NEW( BPy_Particle,
 
253
                                                                 &Particle_Type );
 
254
                        wanted_eff->particle = eff;
 
255
                        return ( PyObject * ) wanted_eff;
 
256
                }
 
257
                object_iter = object_iter->id.next;
 
258
        }
 
259
        Py_INCREF( Py_None );
 
260
        return Py_None;
254
261
}
255
262
 
256
263
/*****************************************************************************/
257
264
/* Function:              Particle_Init                                      */
258
265
/*****************************************************************************/
259
 
PyObject *Particle_Init (void)
 
266
PyObject *Particle_Init( void )
260
267
{
261
 
  PyObject  *submodule;
262
 
  Particle_Type.ob_type = &PyType_Type;
263
 
  submodule = Py_InitModule3("Blender.Particle",M_Particle_methods, M_Particle_doc);
264
 
  return (submodule);
 
268
        PyObject *submodule;
 
269
        Particle_Type.ob_type = &PyType_Type;
 
270
        submodule =
 
271
                Py_InitModule3( "Blender.Particle", M_Particle_methods,
 
272
                                M_Particle_doc );
 
273
        return ( submodule );
265
274
}
266
275
 
267
276
/*****************************************************************************/
268
277
/* Python BPy_Particle methods:                                                */
269
278
/*****************************************************************************/
270
279
 
271
 
PyObject *Particle_getSta(BPy_Particle *self)
272
 
{
273
 
 
274
 
  PartEff*ptr = (PartEff*)self->particle;
275
 
  return PyFloat_FromDouble(ptr->sta);
276
 
}
277
 
 
278
 
 
279
 
 
280
 
PyObject *Particle_setSta(BPy_Particle *self,PyObject *args)
281
 
{  
282
 
  PartEff*ptr = (PartEff*)self->particle;
283
 
        float val = 0;
284
 
        if (!PyArg_ParseTuple(args, "f", &val ))
285
 
    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
286
 
                                                                                                                                 "expected float argument"));
287
 
  ptr->sta = val;
288
 
  Py_INCREF(Py_None);
289
 
  return Py_None;
290
 
}
291
 
PyObject *Particle_getEnd(BPy_Particle *self)
292
 
{
293
 
 
294
 
  PartEff*ptr = (PartEff*)self->particle;
295
 
  return PyFloat_FromDouble(ptr->end);
296
 
}
297
 
 
298
 
 
299
 
 
300
 
PyObject *Particle_setEnd(BPy_Particle *self,PyObject *args)
301
 
{  
302
 
        float val = 0;
303
 
  PartEff*ptr = (PartEff*)self->particle;
304
 
        if (!PyArg_ParseTuple(args, "f", &val ))
305
 
    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
306
 
                                                                                                                                 "expected float argument"));
307
 
  ptr->end = val;
308
 
  Py_INCREF(Py_None);
309
 
  return Py_None;
310
 
}
311
 
 
312
 
PyObject *Particle_getLifetime(BPy_Particle *self)
313
 
{
314
 
 
315
 
  PartEff*ptr = (PartEff*)self->particle;
316
 
  return PyFloat_FromDouble(ptr->lifetime);
317
 
}
318
 
 
319
 
 
320
 
 
321
 
PyObject *Particle_setLifetime(BPy_Particle *self,PyObject *args)
322
 
{  
323
 
  PartEff*ptr = (PartEff*)self->particle;
324
 
        float val = 0;
325
 
        if (!PyArg_ParseTuple(args, "f", &val ))
326
 
    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
327
 
                                                                                                                                 "expected float argument"));
328
 
  ptr->lifetime = val;
329
 
  Py_INCREF(Py_None);
330
 
  return Py_None;
331
 
}
332
 
 
333
 
 
334
 
PyObject *Particle_getNormfac(BPy_Particle *self)
335
 
{
336
 
 
337
 
  PartEff*ptr = (PartEff*)self->particle;
338
 
  return PyFloat_FromDouble(ptr->normfac);
339
 
}
340
 
 
341
 
 
342
 
 
343
 
PyObject *Particle_setNormfac(BPy_Particle *self,PyObject *args)
344
 
{  
345
 
  PartEff*ptr = (PartEff*)self->particle;
346
 
        float val = 0;
347
 
        if (!PyArg_ParseTuple(args, "f", &val ))
348
 
    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
349
 
                                                                                                                                 "expected float argument"));
350
 
  ptr->normfac = val;
351
 
  Py_INCREF(Py_None);
352
 
  return Py_None;
353
 
}
354
 
 
355
 
 
356
 
 
357
 
PyObject *Particle_getObfac(BPy_Particle *self)
358
 
{
359
 
 
360
 
  PartEff*ptr = (PartEff*)self->particle;
361
 
  return PyFloat_FromDouble(ptr->obfac);
362
 
}
363
 
 
364
 
 
365
 
 
366
 
PyObject *Particle_setObfac(BPy_Particle *self,PyObject *args)
367
 
{  
368
 
        float val = 0;
369
 
  PartEff*ptr = (PartEff*)self->particle;
370
 
        if (!PyArg_ParseTuple(args, "f", &val ))
371
 
    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
372
 
                                                                                                                                 "expected float argument"));
373
 
  ptr->obfac = val;
374
 
  Py_INCREF(Py_None);
375
 
  return Py_None;
376
 
}
377
 
 
378
 
 
379
 
 
380
 
PyObject *Particle_getRandfac(BPy_Particle *self)
381
 
{
382
 
 
383
 
  PartEff*ptr = (PartEff*)self->particle;
384
 
  return PyFloat_FromDouble(ptr->randfac);
385
 
}
386
 
 
387
 
 
388
 
 
389
 
PyObject *Particle_setRandfac(BPy_Particle *self,PyObject *args)
390
 
{  
391
 
        float val = 0;
392
 
  PartEff*ptr = (PartEff*)self->particle;
393
 
        if (!PyArg_ParseTuple(args, "f", &val ))
394
 
    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
395
 
                                                                                                                                 "expected float argument"));
396
 
  ptr->randfac = val;
397
 
  Py_INCREF(Py_None);
398
 
  return Py_None;
399
 
}
400
 
 
401
 
 
402
 
 
403
 
PyObject *Particle_getTexfac(BPy_Particle *self)
404
 
{
405
 
 
406
 
  PartEff*ptr = (PartEff*)self->particle;
407
 
  return PyFloat_FromDouble(ptr->texfac);
408
 
}
409
 
 
410
 
 
411
 
 
412
 
PyObject *Particle_setTexfac(BPy_Particle *self,PyObject *args)
413
 
{  
414
 
  PartEff*ptr = (PartEff*)self->particle;
415
 
        float val = 0;
416
 
        if (!PyArg_ParseTuple(args, "f", &val ))
417
 
    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
418
 
                                                                                                                                 "expected float argument"));
419
 
  ptr->texfac = val;
420
 
  Py_INCREF(Py_None);
421
 
  return Py_None;
422
 
}
423
 
 
424
 
 
425
 
 
426
 
PyObject *Particle_getRandlife(BPy_Particle *self)
427
 
{
428
 
 
429
 
  PartEff*ptr = (PartEff*)self->particle;
430
 
  return PyFloat_FromDouble(ptr->randlife);
431
 
}
432
 
 
433
 
 
434
 
 
435
 
PyObject *Particle_setRandlife(BPy_Particle *self,PyObject *args)
436
 
{  
437
 
  PartEff*ptr = (PartEff*)self->particle;
438
 
        float val = 0;
439
 
        if (!PyArg_ParseTuple(args, "f", &val ))
440
 
    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
441
 
                                                                                                                                 "expected float argument"));
442
 
  ptr->randlife = val;
443
 
  Py_INCREF(Py_None);
444
 
  return Py_None;
445
 
}
446
 
 
447
 
 
448
 
 
449
 
PyObject *Particle_getNabla(BPy_Particle *self)
450
 
{
451
 
 
452
 
  PartEff*ptr = (PartEff*)self->particle;
453
 
  return PyFloat_FromDouble(ptr->nabla);
454
 
}
455
 
 
456
 
 
457
 
 
458
 
PyObject *Particle_setNabla(BPy_Particle *self,PyObject *args)
459
 
{  
460
 
  PartEff*ptr = (PartEff*)self->particle;
461
 
        float val = 0;
462
 
        if (!PyArg_ParseTuple(args, "f", &val ))
463
 
    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
464
 
                                                                                                                                 "expected float argument"));
465
 
  ptr->nabla = val;
466
 
  Py_INCREF(Py_None);
467
 
  return Py_None;
468
 
}
469
 
 
470
 
 
471
 
 
472
 
PyObject *Particle_getVectsize(BPy_Particle *self)
473
 
{
474
 
 
475
 
  PartEff*ptr = (PartEff*)self->particle;
476
 
  return PyFloat_FromDouble(ptr->vectsize);
477
 
}
478
 
 
479
 
 
480
 
 
481
 
PyObject *Particle_setVectsize(BPy_Particle *self,PyObject *args)
482
 
{  
483
 
  PartEff*ptr = (PartEff*)self->particle;
484
 
        float val = 0;
485
 
        if (!PyArg_ParseTuple(args, "f", &val ))
486
 
    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
487
 
                                                                                                                                 "expected float argument"));
488
 
  ptr->vectsize = val;
489
 
  Py_INCREF(Py_None);
490
 
  return Py_None;
491
 
}
492
 
 
493
 
 
494
 
PyObject *Particle_getTotpart(BPy_Particle *self)
495
 
{
496
 
 
497
 
  PartEff*ptr = (PartEff*)self->particle;
498
 
  return PyInt_FromLong(ptr->totpart);
499
 
}
500
 
 
501
 
 
502
 
 
503
 
PyObject *Particle_setTotpart(BPy_Particle *self,PyObject *args)
504
 
{  
505
 
        int val = 0;
506
 
  PartEff*ptr = (PartEff*)self->particle;
507
 
        if (!PyArg_ParseTuple(args, "i", &val ))
508
 
    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
509
 
                                                                                                                                 "expected int argument"));
510
 
  ptr->totpart = val;
511
 
  Py_INCREF(Py_None);
512
 
  return Py_None;
513
 
}
514
 
 
515
 
 
516
 
PyObject *Particle_getTotkey(BPy_Particle *self)
517
 
{
518
 
 
519
 
  PartEff*ptr = (PartEff*)self->particle;
520
 
  return PyInt_FromLong(ptr->totkey);
521
 
}
522
 
 
523
 
 
524
 
 
525
 
PyObject *Particle_setTotkey(BPy_Particle *self,PyObject *args)
526
 
{  
527
 
  PartEff*ptr = (PartEff*)self->particle;
528
 
        int val = 0;
529
 
        if (!PyArg_ParseTuple(args, "i", &val ))
530
 
    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
531
 
                                                                                                                                 "expected int argument"));
532
 
  ptr->totkey = val;
533
 
  Py_INCREF(Py_None);
534
 
  return Py_None;
535
 
}
536
 
 
537
 
 
538
 
 
539
 
PyObject *Particle_getSeed(BPy_Particle *self)
540
 
{
541
 
 
542
 
  PartEff*ptr = (PartEff*)self->particle;
543
 
  return PyInt_FromLong(ptr->seed);
544
 
}
545
 
 
546
 
 
547
 
 
548
 
PyObject *Particle_setSeed(BPy_Particle *self,PyObject *args)
549
 
{  
550
 
  PartEff*ptr = (PartEff*)self->particle;
551
 
        int val = 0;
552
 
        if (!PyArg_ParseTuple(args, "i", &val ))
553
 
    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
554
 
                                                                                                                                 "expected int argument"));
555
 
  ptr->seed = val;
556
 
  Py_INCREF(Py_None);
557
 
  return Py_None;
558
 
}
559
 
 
560
 
PyObject *Particle_getForce(BPy_Particle *self)
561
 
{
562
 
 
563
 
  PartEff*ptr = (PartEff*)self->particle;
564
 
  return Py_BuildValue("(f,f,f)",ptr->force[0],ptr->force[1],ptr->force[2]);
565
 
}
566
 
 
567
 
 
568
 
PyObject *Particle_setForce(BPy_Particle *self,PyObject *args)
569
 
{  
570
 
  PartEff*ptr = (PartEff*)self->particle;
 
280
PyObject *Particle_getSta( BPy_Particle * self )
 
281
{
 
282
 
 
283
        PartEff *ptr = ( PartEff * ) self->particle;
 
284
        return PyFloat_FromDouble( ptr->sta );
 
285
}
 
286
 
 
287
 
 
288
 
 
289
PyObject *Particle_setSta( BPy_Particle * self, PyObject * args )
 
290
{
 
291
        PartEff *ptr = ( PartEff * ) self->particle;
 
292
        float val = 0;
 
293
        if( !PyArg_ParseTuple( args, "f", &val ) )
 
294
                return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 
295
                                                "expected float argument" ) );
 
296
        ptr->sta = val;
 
297
        Py_INCREF( Py_None );
 
298
        return Py_None;
 
299
}
 
300
 
 
301
PyObject *Particle_getEnd( BPy_Particle * self )
 
302
{
 
303
 
 
304
        PartEff *ptr = ( PartEff * ) self->particle;
 
305
        return PyFloat_FromDouble( ptr->end );
 
306
}
 
307
 
 
308
 
 
309
 
 
310
PyObject *Particle_setEnd( BPy_Particle * self, PyObject * args )
 
311
{
 
312
        float val = 0;
 
313
        PartEff *ptr = ( PartEff * ) self->particle;
 
314
        if( !PyArg_ParseTuple( args, "f", &val ) )
 
315
                return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 
316
                                                "expected float argument" ) );
 
317
        ptr->end = val;
 
318
        Py_INCREF( Py_None );
 
319
        return Py_None;
 
320
}
 
321
 
 
322
PyObject *Particle_getLifetime( BPy_Particle * self )
 
323
{
 
324
 
 
325
        PartEff *ptr = ( PartEff * ) self->particle;
 
326
        return PyFloat_FromDouble( ptr->lifetime );
 
327
}
 
328
 
 
329
 
 
330
 
 
331
PyObject *Particle_setLifetime( BPy_Particle * self, PyObject * args )
 
332
{
 
333
        PartEff *ptr = ( PartEff * ) self->particle;
 
334
        float val = 0;
 
335
        if( !PyArg_ParseTuple( args, "f", &val ) )
 
336
                return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 
337
                                                "expected float argument" ) );
 
338
        ptr->lifetime = val;
 
339
        Py_INCREF( Py_None );
 
340
        return Py_None;
 
341
}
 
342
 
 
343
 
 
344
PyObject *Particle_getNormfac( BPy_Particle * self )
 
345
{
 
346
 
 
347
        PartEff *ptr = ( PartEff * ) self->particle;
 
348
        return PyFloat_FromDouble( ptr->normfac );
 
349
}
 
350
 
 
351
 
 
352
 
 
353
PyObject *Particle_setNormfac( BPy_Particle * self, PyObject * args )
 
354
{
 
355
        PartEff *ptr = ( PartEff * ) self->particle;
 
356
        float val = 0;
 
357
        if( !PyArg_ParseTuple( args, "f", &val ) )
 
358
                return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 
359
                                                "expected float argument" ) );
 
360
        ptr->normfac = val;
 
361
        Py_INCREF( Py_None );
 
362
        return Py_None;
 
363
}
 
364
 
 
365
 
 
366
 
 
367
PyObject *Particle_getObfac( BPy_Particle * self )
 
368
{
 
369
 
 
370
        PartEff *ptr = ( PartEff * ) self->particle;
 
371
        return PyFloat_FromDouble( ptr->obfac );
 
372
}
 
373
 
 
374
 
 
375
 
 
376
PyObject *Particle_setObfac( BPy_Particle * self, PyObject * args )
 
377
{
 
378
        float val = 0;
 
379
        PartEff *ptr = ( PartEff * ) self->particle;
 
380
        if( !PyArg_ParseTuple( args, "f", &val ) )
 
381
                return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 
382
                                                "expected float argument" ) );
 
383
        ptr->obfac = val;
 
384
        Py_INCREF( Py_None );
 
385
        return Py_None;
 
386
}
 
387
 
 
388
 
 
389
 
 
390
PyObject *Particle_getRandfac( BPy_Particle * self )
 
391
{
 
392
 
 
393
        PartEff *ptr = ( PartEff * ) self->particle;
 
394
        return PyFloat_FromDouble( ptr->randfac );
 
395
}
 
396
 
 
397
 
 
398
 
 
399
PyObject *Particle_setRandfac( BPy_Particle * self, PyObject * args )
 
400
{
 
401
        float val = 0;
 
402
        PartEff *ptr = ( PartEff * ) self->particle;
 
403
        if( !PyArg_ParseTuple( args, "f", &val ) )
 
404
                return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 
405
                                                "expected float argument" ) );
 
406
        ptr->randfac = val;
 
407
        Py_INCREF( Py_None );
 
408
        return Py_None;
 
409
}
 
410
 
 
411
 
 
412
 
 
413
PyObject *Particle_getTexfac( BPy_Particle * self )
 
414
{
 
415
 
 
416
        PartEff *ptr = ( PartEff * ) self->particle;
 
417
        return PyFloat_FromDouble( ptr->texfac );
 
418
}
 
419
 
 
420
 
 
421
 
 
422
PyObject *Particle_setTexfac( BPy_Particle * self, PyObject * args )
 
423
{
 
424
        PartEff *ptr = ( PartEff * ) self->particle;
 
425
        float val = 0;
 
426
        if( !PyArg_ParseTuple( args, "f", &val ) )
 
427
                return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 
428
                                                "expected float argument" ) );
 
429
        ptr->texfac = val;
 
430
        Py_INCREF( Py_None );
 
431
        return Py_None;
 
432
}
 
433
 
 
434
 
 
435
 
 
436
PyObject *Particle_getRandlife( BPy_Particle * self )
 
437
{
 
438
 
 
439
        PartEff *ptr = ( PartEff * ) self->particle;
 
440
        return PyFloat_FromDouble( ptr->randlife );
 
441
}
 
442
 
 
443
 
 
444
 
 
445
PyObject *Particle_setRandlife( BPy_Particle * self, PyObject * args )
 
446
{
 
447
        PartEff *ptr = ( PartEff * ) self->particle;
 
448
        float val = 0;
 
449
        if( !PyArg_ParseTuple( args, "f", &val ) )
 
450
                return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 
451
                                                "expected float argument" ) );
 
452
        ptr->randlife = val;
 
453
        Py_INCREF( Py_None );
 
454
        return Py_None;
 
455
}
 
456
 
 
457
 
 
458
 
 
459
PyObject *Particle_getNabla( BPy_Particle * self )
 
460
{
 
461
 
 
462
        PartEff *ptr = ( PartEff * ) self->particle;
 
463
        return PyFloat_FromDouble( ptr->nabla );
 
464
}
 
465
 
 
466
 
 
467
 
 
468
PyObject *Particle_setNabla( BPy_Particle * self, PyObject * args )
 
469
{
 
470
        PartEff *ptr = ( PartEff * ) self->particle;
 
471
        float val = 0;
 
472
        if( !PyArg_ParseTuple( args, "f", &val ) )
 
473
                return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 
474
                                                "expected float argument" ) );
 
475
        ptr->nabla = val;
 
476
        Py_INCREF( Py_None );
 
477
        return Py_None;
 
478
}
 
479
 
 
480
 
 
481
 
 
482
PyObject *Particle_getVectsize( BPy_Particle * self )
 
483
{
 
484
 
 
485
        PartEff *ptr = ( PartEff * ) self->particle;
 
486
        return PyFloat_FromDouble( ptr->vectsize );
 
487
}
 
488
 
 
489
 
 
490
 
 
491
PyObject *Particle_setVectsize( BPy_Particle * self, PyObject * args )
 
492
{
 
493
        PartEff *ptr = ( PartEff * ) self->particle;
 
494
        float val = 0;
 
495
        if( !PyArg_ParseTuple( args, "f", &val ) )
 
496
                return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 
497
                                                "expected float argument" ) );
 
498
        ptr->vectsize = val;
 
499
        Py_INCREF( Py_None );
 
500
        return Py_None;
 
501
}
 
502
 
 
503
 
 
504
PyObject *Particle_getTotpart( BPy_Particle * self )
 
505
{
 
506
 
 
507
        PartEff *ptr = ( PartEff * ) self->particle;
 
508
        return PyInt_FromLong( ptr->totpart );
 
509
}
 
510
 
 
511
 
 
512
 
 
513
PyObject *Particle_setTotpart( BPy_Particle * self, PyObject * args )
 
514
{
 
515
        int val = 0;
 
516
        PartEff *ptr = ( PartEff * ) self->particle;
 
517
        if( !PyArg_ParseTuple( args, "i", &val ) )
 
518
                return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 
519
                                                "expected int argument" ) );
 
520
        ptr->totpart = val;
 
521
        Py_INCREF( Py_None );
 
522
        return Py_None;
 
523
}
 
524
 
 
525
 
 
526
PyObject *Particle_getTotkey( BPy_Particle * self )
 
527
{
 
528
 
 
529
        PartEff *ptr = ( PartEff * ) self->particle;
 
530
        return PyInt_FromLong( ptr->totkey );
 
531
}
 
532
 
 
533
 
 
534
 
 
535
PyObject *Particle_setTotkey( BPy_Particle * self, PyObject * args )
 
536
{
 
537
        PartEff *ptr = ( PartEff * ) self->particle;
 
538
        int val = 0;
 
539
        if( !PyArg_ParseTuple( args, "i", &val ) )
 
540
                return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 
541
                                                "expected int argument" ) );
 
542
        ptr->totkey = val;
 
543
        Py_INCREF( Py_None );
 
544
        return Py_None;
 
545
}
 
546
 
 
547
 
 
548
 
 
549
PyObject *Particle_getSeed( BPy_Particle * self )
 
550
{
 
551
 
 
552
        PartEff *ptr = ( PartEff * ) self->particle;
 
553
        return PyInt_FromLong( ptr->seed );
 
554
}
 
555
 
 
556
 
 
557
 
 
558
PyObject *Particle_setSeed( BPy_Particle * self, PyObject * args )
 
559
{
 
560
        PartEff *ptr = ( PartEff * ) self->particle;
 
561
        int val = 0;
 
562
        if( !PyArg_ParseTuple( args, "i", &val ) )
 
563
                return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 
564
                                                "expected int argument" ) );
 
565
        ptr->seed = val;
 
566
        Py_INCREF( Py_None );
 
567
        return Py_None;
 
568
}
 
569
 
 
570
PyObject *Particle_getForce( BPy_Particle * self )
 
571
{
 
572
 
 
573
        PartEff *ptr = ( PartEff * ) self->particle;
 
574
        return Py_BuildValue( "(f,f,f)", ptr->force[0], ptr->force[1],
 
575
                              ptr->force[2] );
 
576
}
 
577
 
 
578
 
 
579
PyObject *Particle_setForce( BPy_Particle * self, PyObject * args )
 
580
{
 
581
        PartEff *ptr = ( PartEff * ) self->particle;
571
582
        float val[3];
572
 
        if (PyTuple_Size(args) == 1)args = PyTuple_GetItem(args,0);
573
 
        val[0] = PyFloat_AsDouble(PyTuple_GetItem(args,0));
574
 
        val[1] = PyFloat_AsDouble(PyTuple_GetItem(args,1));
575
 
        val[2] = PyFloat_AsDouble(PyTuple_GetItem(args,2));
 
583
        if( PyTuple_Size( args ) == 1 )
 
584
                args = PyTuple_GetItem( args, 0 );
 
585
        val[0] = PyFloat_AsDouble( PyTuple_GetItem( args, 0 ) );
 
586
        val[1] = PyFloat_AsDouble( PyTuple_GetItem( args, 1 ) );
 
587
        val[2] = PyFloat_AsDouble( PyTuple_GetItem( args, 2 ) );
576
588
        /*
577
 
        if (!PyArg_ParseTuple(args, "fff", val,val+1,val+2 ))
578
 
    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
579
 
                                                                                                                                 "expected three float arguments"));
580
 
        */
581
 
  ptr->force[0] = val[0];ptr->force[1] = val[1];ptr->force[2] = val[2];
582
 
  Py_INCREF(Py_None);
583
 
  return Py_None;
584
 
}
585
 
 
586
 
PyObject *Particle_getMult(BPy_Particle *self)
587
 
{
588
 
 
589
 
  PartEff*ptr = (PartEff*)self->particle;
590
 
  return Py_BuildValue("(f,f,f,f)",
591
 
                                                                                         ptr->mult[0],ptr->mult[1],ptr->mult[2],ptr->mult[3]);
592
 
}
593
 
 
594
 
 
595
 
PyObject *Particle_setMult(BPy_Particle *self,PyObject *args)
596
 
{  
597
 
  PartEff*ptr = (PartEff*)self->particle;
598
 
  float val[4];
599
 
if (PyTuple_Size(args) == 1)args = PyTuple_GetItem(args,0);
600
 
        val[0] = PyFloat_AsDouble(PyTuple_GetItem(args,0));
601
 
        val[1] = PyFloat_AsDouble(PyTuple_GetItem(args,1));
602
 
        val[2] = PyFloat_AsDouble(PyTuple_GetItem(args,2));
603
 
        val[3] = PyFloat_AsDouble(PyTuple_GetItem(args,3));
604
 
  ptr->mult[0] = val[0];ptr->mult[1] = val[1];
605
 
  ptr->mult[2] = val[2];ptr->mult[3] = val[3];
606
 
  Py_INCREF(Py_None);
607
 
  return Py_None;
608
 
}
609
 
 
610
 
 
611
 
 
612
 
 
613
 
PyObject *Particle_getLife(BPy_Particle *self)
614
 
{
615
 
 
616
 
  PartEff*ptr = (PartEff*)self->particle;
617
 
  return Py_BuildValue("(f,f,f,f)",
618
 
                                                                                         ptr->life[0],ptr->life[1],ptr->life[2],ptr->life[3]);
619
 
}
620
 
 
621
 
 
622
 
PyObject *Particle_setLife(BPy_Particle *self,PyObject *args)
623
 
{  
624
 
  PartEff*ptr = (PartEff*)self->particle;
625
 
  float val[4];
626
 
if (PyTuple_Size(args) == 1)args = PyTuple_GetItem(args,0);
627
 
        val[0] = PyFloat_AsDouble(PyTuple_GetItem(args,0));
628
 
        val[1] = PyFloat_AsDouble(PyTuple_GetItem(args,1));
629
 
        val[2] = PyFloat_AsDouble(PyTuple_GetItem(args,2));
630
 
        val[3] = PyFloat_AsDouble(PyTuple_GetItem(args,3));
631
 
  ptr->life[0] = val[0];ptr->life[1] = val[1];
632
 
  ptr->life[2] = val[2];ptr->life[3] = val[3];
633
 
  Py_INCREF(Py_None);
634
 
  return Py_None;
635
 
}
636
 
 
637
 
 
638
 
 
639
 
PyObject *Particle_getChild(BPy_Particle *self)
640
 
{
641
 
 
642
 
  PartEff*ptr = (PartEff*)self->particle;
643
 
  return Py_BuildValue("(f,f,f,f)",
644
 
                                                                                         ptr->child[0],ptr->child[1],ptr->child[2],ptr->child[3]);
645
 
}
646
 
 
647
 
 
648
 
PyObject *Particle_setChild(BPy_Particle *self,PyObject *args)
649
 
{  
650
 
  PartEff*ptr = (PartEff*)self->particle;
651
 
  float val[4];
652
 
if (PyTuple_Size(args) == 1)args = PyTuple_GetItem(args,0);
653
 
        val[0] = PyFloat_AsDouble(PyTuple_GetItem(args,0));
654
 
        val[1] = PyFloat_AsDouble(PyTuple_GetItem(args,1));
655
 
        val[2] = PyFloat_AsDouble(PyTuple_GetItem(args,2));
656
 
        val[3] = PyFloat_AsDouble(PyTuple_GetItem(args,3));
657
 
  ptr->child[0] = val[0];ptr->child[1] = val[1];
658
 
  ptr->child[2] = val[2];ptr->child[3] = val[3];
659
 
  Py_INCREF(Py_None);
660
 
  return Py_None;
661
 
}
662
 
 
663
 
 
664
 
 
665
 
PyObject *Particle_getMat(BPy_Particle *self)
666
 
{
667
 
 
668
 
  PartEff*ptr = (PartEff*)self->particle;
669
 
  return Py_BuildValue("(f,f,f,f)",
670
 
                                                                                         ptr->mat[0],ptr->mat[1],ptr->mat[2],ptr->mat[3]);
671
 
}
672
 
 
673
 
 
674
 
PyObject *Particle_setMat(BPy_Particle *self,PyObject *args)
675
 
{  
676
 
  PartEff*ptr = (PartEff*)self->particle;
677
 
  float val[4];
678
 
if (PyTuple_Size(args) == 1)args = PyTuple_GetItem(args,0);
679
 
        val[0] = PyFloat_AsDouble(PyTuple_GetItem(args,0));
680
 
        val[1] = PyFloat_AsDouble(PyTuple_GetItem(args,1));
681
 
        val[2] = PyFloat_AsDouble(PyTuple_GetItem(args,2));
682
 
        val[3] = PyFloat_AsDouble(PyTuple_GetItem(args,3));
683
 
  ptr->mat[0] = val[0];ptr->mat[1] = val[1];
684
 
  ptr->mat[2] = val[2];ptr->mat[3] = val[3];
685
 
  Py_INCREF(Py_None);
686
 
  return Py_None;
687
 
}
688
 
 
689
 
 
690
 
PyObject *Particle_getDefvec(BPy_Particle *self)
691
 
{
692
 
 
693
 
  PartEff*ptr = (PartEff*)self->particle;
694
 
  return Py_BuildValue("(f,f,f)",
695
 
                                                                                         ptr->defvec[0],ptr->defvec[1],ptr->defvec[2]);
696
 
}
697
 
 
698
 
 
699
 
PyObject *Particle_setDefvec(BPy_Particle *self,PyObject *args)
700
 
{  
701
 
  PartEff*ptr = (PartEff*)self->particle;
702
 
  float val[3];
703
 
if (PyTuple_Size(args) == 1)args = PyTuple_GetItem(args,0);
704
 
        val[0] = PyFloat_AsDouble(PyTuple_GetItem(args,0));
705
 
        val[1] = PyFloat_AsDouble(PyTuple_GetItem(args,1));
706
 
        val[2] = PyFloat_AsDouble(PyTuple_GetItem(args,2));
707
 
  ptr->defvec[0] = val[0];ptr->defvec[1] = val[1]; ptr->defvec[2] = val[2];
708
 
  Py_INCREF(Py_None);
709
 
  return Py_None;
 
589
           if (!PyArg_ParseTuple(args, "fff", val,val+1,val+2 ))
 
590
           return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
 
591
           "expected three float arguments"));
 
592
         */
 
593
        ptr->force[0] = val[0];
 
594
        ptr->force[1] = val[1];
 
595
        ptr->force[2] = val[2];
 
596
        Py_INCREF( Py_None );
 
597
        return Py_None;
 
598
}
 
599
 
 
600
PyObject *Particle_getMult( BPy_Particle * self )
 
601
{
 
602
 
 
603
        PartEff *ptr = ( PartEff * ) self->particle;
 
604
        return Py_BuildValue( "(f,f,f,f)",
 
605
                              ptr->mult[0], ptr->mult[1], ptr->mult[2],
 
606
                              ptr->mult[3] );
 
607
}
 
608
 
 
609
 
 
610
PyObject *Particle_setMult( BPy_Particle * self, PyObject * args )
 
611
{
 
612
        PartEff *ptr = ( PartEff * ) self->particle;
 
613
        float val[4];
 
614
        if( PyTuple_Size( args ) == 1 )
 
615
                args = PyTuple_GetItem( args, 0 );
 
616
        val[0] = PyFloat_AsDouble( PyTuple_GetItem( args, 0 ) );
 
617
        val[1] = PyFloat_AsDouble( PyTuple_GetItem( args, 1 ) );
 
618
        val[2] = PyFloat_AsDouble( PyTuple_GetItem( args, 2 ) );
 
619
        val[3] = PyFloat_AsDouble( PyTuple_GetItem( args, 3 ) );
 
620
        ptr->mult[0] = val[0];
 
621
        ptr->mult[1] = val[1];
 
622
        ptr->mult[2] = val[2];
 
623
        ptr->mult[3] = val[3];
 
624
        Py_INCREF( Py_None );
 
625
        return Py_None;
 
626
}
 
627
 
 
628
 
 
629
 
 
630
 
 
631
PyObject *Particle_getLife( BPy_Particle * self )
 
632
{
 
633
 
 
634
        PartEff *ptr = ( PartEff * ) self->particle;
 
635
        return Py_BuildValue( "(f,f,f,f)",
 
636
                              ptr->life[0], ptr->life[1], ptr->life[2],
 
637
                              ptr->life[3] );
 
638
}
 
639
 
 
640
 
 
641
PyObject *Particle_setLife( BPy_Particle * self, PyObject * args )
 
642
{
 
643
        PartEff *ptr = ( PartEff * ) self->particle;
 
644
        float val[4];
 
645
        if( PyTuple_Size( args ) == 1 )
 
646
                args = PyTuple_GetItem( args, 0 );
 
647
        val[0] = PyFloat_AsDouble( PyTuple_GetItem( args, 0 ) );
 
648
        val[1] = PyFloat_AsDouble( PyTuple_GetItem( args, 1 ) );
 
649
        val[2] = PyFloat_AsDouble( PyTuple_GetItem( args, 2 ) );
 
650
        val[3] = PyFloat_AsDouble( PyTuple_GetItem( args, 3 ) );
 
651
        ptr->life[0] = val[0];
 
652
        ptr->life[1] = val[1];
 
653
        ptr->life[2] = val[2];
 
654
        ptr->life[3] = val[3];
 
655
        Py_INCREF( Py_None );
 
656
        return Py_None;
 
657
}
 
658
 
 
659
 
 
660
 
 
661
PyObject *Particle_getChild( BPy_Particle * self )
 
662
{
 
663
 
 
664
        PartEff *ptr = ( PartEff * ) self->particle;
 
665
        return Py_BuildValue( "(f,f,f,f)",
 
666
                              ptr->child[0], ptr->child[1], ptr->child[2],
 
667
                              ptr->child[3] );
 
668
}
 
669
 
 
670
 
 
671
PyObject *Particle_setChild( BPy_Particle * self, PyObject * args )
 
672
{
 
673
        PartEff *ptr = ( PartEff * ) self->particle;
 
674
        float val[4];
 
675
        if( PyTuple_Size( args ) == 1 )
 
676
                args = PyTuple_GetItem( args, 0 );
 
677
        val[0] = PyFloat_AsDouble( PyTuple_GetItem( args, 0 ) );
 
678
        val[1] = PyFloat_AsDouble( PyTuple_GetItem( args, 1 ) );
 
679
        val[2] = PyFloat_AsDouble( PyTuple_GetItem( args, 2 ) );
 
680
        val[3] = PyFloat_AsDouble( PyTuple_GetItem( args, 3 ) );
 
681
        ptr->child[0] = val[0];
 
682
        ptr->child[1] = val[1];
 
683
        ptr->child[2] = val[2];
 
684
        ptr->child[3] = val[3];
 
685
        Py_INCREF( Py_None );
 
686
        return Py_None;
 
687
}
 
688
 
 
689
 
 
690
 
 
691
PyObject *Particle_getMat( BPy_Particle * self )
 
692
{
 
693
 
 
694
        PartEff *ptr = ( PartEff * ) self->particle;
 
695
        return Py_BuildValue( "(f,f,f,f)",
 
696
                              ptr->mat[0], ptr->mat[1], ptr->mat[2],
 
697
                              ptr->mat[3] );
 
698
}
 
699
 
 
700
 
 
701
PyObject *Particle_setMat( BPy_Particle * self, PyObject * args )
 
702
{
 
703
        PartEff *ptr = ( PartEff * ) self->particle;
 
704
        float val[4];
 
705
        if( PyTuple_Size( args ) == 1 )
 
706
                args = PyTuple_GetItem( args, 0 );
 
707
        val[0] = PyFloat_AsDouble( PyTuple_GetItem( args, 0 ) );
 
708
        val[1] = PyFloat_AsDouble( PyTuple_GetItem( args, 1 ) );
 
709
        val[2] = PyFloat_AsDouble( PyTuple_GetItem( args, 2 ) );
 
710
        val[3] = PyFloat_AsDouble( PyTuple_GetItem( args, 3 ) );
 
711
        ptr->mat[0] = val[0];
 
712
        ptr->mat[1] = val[1];
 
713
        ptr->mat[2] = val[2];
 
714
        ptr->mat[3] = val[3];
 
715
        Py_INCREF( Py_None );
 
716
        return Py_None;
 
717
}
 
718
 
 
719
 
 
720
PyObject *Particle_getDefvec( BPy_Particle * self )
 
721
{
 
722
 
 
723
        PartEff *ptr = ( PartEff * ) self->particle;
 
724
        return Py_BuildValue( "(f,f,f)",
 
725
                              ptr->defvec[0], ptr->defvec[1], ptr->defvec[2] );
 
726
}
 
727
 
 
728
 
 
729
PyObject *Particle_setDefvec( BPy_Particle * self, PyObject * args )
 
730
{
 
731
        PartEff *ptr = ( PartEff * ) self->particle;
 
732
        float val[3];
 
733
        if( PyTuple_Size( args ) == 1 )
 
734
                args = PyTuple_GetItem( args, 0 );
 
735
        val[0] = PyFloat_AsDouble( PyTuple_GetItem( args, 0 ) );
 
736
        val[1] = PyFloat_AsDouble( PyTuple_GetItem( args, 1 ) );
 
737
        val[2] = PyFloat_AsDouble( PyTuple_GetItem( args, 2 ) );
 
738
        ptr->defvec[0] = val[0];
 
739
        ptr->defvec[1] = val[1];
 
740
        ptr->defvec[2] = val[2];
 
741
        Py_INCREF( Py_None );
 
742
        return Py_None;
710
743
}
711
744
 
712
745
 
716
749
/* Description: This is a callback function for the BPy_Particle type. It is   */
717
750
/*              the destructor function.                                     */
718
751
/*****************************************************************************/
719
 
void ParticleDeAlloc (BPy_Particle *self)
 
752
void ParticleDeAlloc( BPy_Particle * self )
720
753
{
721
 
  PartEff*ptr = (PartEff*)self;
722
 
  PyObject_DEL (ptr);
 
754
        PartEff *ptr = ( PartEff * ) self;
 
755
        PyObject_DEL( ptr );
723
756
}
724
757
 
725
758
/*****************************************************************************/
726
759
/* Function:    ParticleGetAttr                                              */
727
 
/* Description: This is a callback function for the BPy_Particle type. It is   */
728
 
/*              the function that accesses BPy_Particle "member variables" and */
729
 
/*              methods.                                                     */
 
760
/* Description: This is a callback function for the BPy_Particle type. It is */
 
761
/*              the function that accesses BPy_Particle "member variables"   */
 
762
/*              and  methods.                                                */
730
763
/*****************************************************************************/
731
764
 
732
765
 
733
 
PyObject *ParticleGetAttr (BPy_Particle *self, char *name)
 
766
PyObject *ParticleGetAttr( BPy_Particle * self, char *name )
734
767
{
735
768
 
736
 
  if (strcmp (name, "seed") == 0)
737
 
    return Particle_getSeed (self);
738
 
  else if (strcmp (name, "nabla") == 0)
739
 
    return Particle_getNabla (self); 
740
 
  else if (strcmp (name, "sta") == 0)
741
 
    return Particle_getSta (self);  
742
 
  else if (strcmp (name, "end") == 0)
743
 
    return Particle_getEnd (self);   
744
 
  else if (strcmp (name, "lifetime") == 0)
745
 
    return Particle_getLifetime (self);   
746
 
  else if (strcmp (name, "normfac") == 0)
747
 
    return Particle_getNormfac (self);   
748
 
  else if (strcmp (name, "obfac") == 0)
749
 
    return Particle_getObfac (self);   
750
 
  else if (strcmp (name, "randfac") == 0)
751
 
    return Particle_getRandfac (self);   
752
 
  else if (strcmp (name, "texfac") == 0)
753
 
    return Particle_getTexfac (self);   
754
 
  else if (strcmp (name, "randlife") == 0)
755
 
    return Particle_getRandlife (self);  
756
 
  else if (strcmp (name, "vectsize") == 0)
757
 
    return Particle_getVectsize (self);  
758
 
  else if (strcmp (name, "totpart") == 0)
759
 
    return Particle_getTotpart (self);  
760
 
  else if (strcmp (name, "force") == 0)
761
 
    return Particle_getForce (self);   
762
 
  else if (strcmp (name, "mult") == 0)
763
 
    return Particle_getMult (self);    
764
 
  else if (strcmp (name, "life") == 0)
765
 
    return Particle_getLife (self);     
766
 
  else if (strcmp (name, "child") == 0)
767
 
    return Particle_getChild (self);     
768
 
  else if (strcmp (name, "mat") == 0)
769
 
    return Particle_getMat (self);      
770
 
  else if (strcmp (name, "defvec") == 0)
771
 
    return Particle_getDefvec (self); 
772
 
 
773
 
 
774
 
  return Py_FindMethod(BPy_Particle_methods, (PyObject *)self, name);
 
769
        if( strcmp( name, "seed" ) == 0 )
 
770
                return Particle_getSeed( self );
 
771
        else if( strcmp( name, "nabla" ) == 0 )
 
772
                return Particle_getNabla( self );
 
773
        else if( strcmp( name, "sta" ) == 0 )
 
774
                return Particle_getSta( self );
 
775
        else if( strcmp( name, "end" ) == 0 )
 
776
                return Particle_getEnd( self );
 
777
        else if( strcmp( name, "lifetime" ) == 0 )
 
778
                return Particle_getLifetime( self );
 
779
        else if( strcmp( name, "normfac" ) == 0 )
 
780
                return Particle_getNormfac( self );
 
781
        else if( strcmp( name, "obfac" ) == 0 )
 
782
                return Particle_getObfac( self );
 
783
        else if( strcmp( name, "randfac" ) == 0 )
 
784
                return Particle_getRandfac( self );
 
785
        else if( strcmp( name, "texfac" ) == 0 )
 
786
                return Particle_getTexfac( self );
 
787
        else if( strcmp( name, "randlife" ) == 0 )
 
788
                return Particle_getRandlife( self );
 
789
        else if( strcmp( name, "vectsize" ) == 0 )
 
790
                return Particle_getVectsize( self );
 
791
        else if( strcmp( name, "totpart" ) == 0 )
 
792
                return Particle_getTotpart( self );
 
793
        else if( strcmp( name, "force" ) == 0 )
 
794
                return Particle_getForce( self );
 
795
        else if( strcmp( name, "mult" ) == 0 )
 
796
                return Particle_getMult( self );
 
797
        else if( strcmp( name, "life" ) == 0 )
 
798
                return Particle_getLife( self );
 
799
        else if( strcmp( name, "child" ) == 0 )
 
800
                return Particle_getChild( self );
 
801
        else if( strcmp( name, "mat" ) == 0 )
 
802
                return Particle_getMat( self );
 
803
        else if( strcmp( name, "defvec" ) == 0 )
 
804
                return Particle_getDefvec( self );
 
805
 
 
806
 
 
807
        return Py_FindMethod( BPy_Particle_methods, ( PyObject * ) self,
 
808
                              name );
775
809
}
776
810
 
777
811
/*****************************************************************************/
778
812
/* Function:    ParticleSetAttr                                              */
779
 
/* Description: This is a callback function for the BPy_Particle type. It is th*/
780
 
/*              function that sets Particle Data attributes (member vars)    */
 
813
/* Description: This is a callback function for the BPy_Particle type.     */
 
814
/*              It is the  function that sets Particle Data attributes     */
 
815
/*              (member vars)    */
781
816
/*****************************************************************************/
782
 
int ParticleSetAttr (BPy_Particle *self, char *name, PyObject *value)
 
817
int ParticleSetAttr( BPy_Particle * self, char *name, PyObject * value )
783
818
{
784
819
 
785
 
  PyObject *valtuple; 
786
 
  PyObject *error = NULL;
787
 
 
788
 
  valtuple = Py_BuildValue("(N)", value);
789
 
 
790
 
  if (!valtuple)
791
 
    return EXPP_ReturnIntError(PyExc_MemoryError,
792
 
                                                                                                                         "ParticleSetAttr: couldn't create PyTuple");
793
 
 
794
 
  if (strcmp (name, "seed") == 0)
795
 
    error = Particle_setSeed (self, valtuple);
796
 
  else if (strcmp (name, "nabla") == 0)
797
 
    error = Particle_setNabla (self, valtuple); 
798
 
  else if (strcmp (name, "sta") == 0)
799
 
    error = Particle_setSta (self, valtuple);  
800
 
  else if (strcmp (name, "end") == 0)
801
 
    error = Particle_setEnd (self, valtuple);   
802
 
  else if (strcmp (name, "lifetime") == 0)
803
 
    error = Particle_setLifetime (self, valtuple);   
804
 
  else if (strcmp (name, "normfac") == 0)
805
 
    error = Particle_setNormfac (self, valtuple);   
806
 
  else if (strcmp (name, "obfac") == 0)
807
 
    error = Particle_setObfac (self, valtuple);   
808
 
  else if (strcmp (name, "randfac") == 0)
809
 
    error = Particle_setRandfac (self, valtuple);   
810
 
  else if (strcmp (name, "texfac") == 0)
811
 
    error = Particle_setTexfac (self, valtuple);   
812
 
  else if (strcmp (name, "randlife") == 0)
813
 
    error = Particle_setRandlife (self, valtuple);  
814
 
  else if (strcmp (name, "nabla") == 0)
815
 
    error = Particle_setNabla (self, valtuple);  
816
 
  else if (strcmp (name, "vectsize") == 0)
817
 
    error = Particle_setVectsize (self, valtuple);  
818
 
  else if (strcmp (name, "totpart") == 0)
819
 
    error = Particle_setTotpart (self, valtuple);   
820
 
  else if (strcmp (name, "seed") == 0)
821
 
    error = Particle_setSeed (self, valtuple);   
822
 
  else if (strcmp (name, "force") == 0)
823
 
    error = Particle_setForce (self, valtuple);    
824
 
  else if (strcmp (name, "mult") == 0)
825
 
    error = Particle_setMult (self, valtuple);     
826
 
  else if (strcmp (name, "life") == 0)
827
 
    error = Particle_setLife (self, valtuple);     
828
 
  else if (strcmp (name, "child") == 0)
829
 
    error = Particle_setChild (self, valtuple);     
830
 
  else if (strcmp (name, "mat") == 0)
831
 
    error = Particle_setMat (self, valtuple);     
832
 
  else if (strcmp (name, "defvec") == 0)
833
 
    error = Particle_setDefvec (self, valtuple); 
834
 
 
835
 
  else {
836
 
    Py_DECREF(valtuple);
837
 
 
838
 
    if ((strcmp (name, "Types") == 0) ||
839
 
        (strcmp (name, "Modes") == 0))  
840
 
      return (EXPP_ReturnIntError (PyExc_AttributeError,
841
 
                                                                                                                                         "constant dictionary -- cannot be changed"));
842
 
 
843
 
    else 
844
 
      return (EXPP_ReturnIntError (PyExc_KeyError,
845
 
                                                                                                                                         "attribute not found"));
846
 
  }
847
 
 
848
 
  /*Py_DECREF(valtuple);*/
849
 
  if (error != Py_None) return -1;
850
 
 
851
 
  Py_DECREF(Py_None);
852
 
  return 0; 
 
820
        PyObject *valtuple;
 
821
        PyObject *error = NULL;
 
822
 
 
823
        valtuple = Py_BuildValue( "(N)", value );
 
824
 
 
825
        if( !valtuple )
 
826
                return EXPP_ReturnIntError( PyExc_MemoryError,
 
827
                                            "ParticleSetAttr: couldn't create PyTuple" );
 
828
 
 
829
        if( strcmp( name, "seed" ) == 0 )
 
830
                error = Particle_setSeed( self, valtuple );
 
831
        else if( strcmp( name, "nabla" ) == 0 )
 
832
                error = Particle_setNabla( self, valtuple );
 
833
        else if( strcmp( name, "sta" ) == 0 )
 
834
                error = Particle_setSta( self, valtuple );
 
835
        else if( strcmp( name, "end" ) == 0 )
 
836
                error = Particle_setEnd( self, valtuple );
 
837
        else if( strcmp( name, "lifetime" ) == 0 )
 
838
                error = Particle_setLifetime( self, valtuple );
 
839
        else if( strcmp( name, "normfac" ) == 0 )
 
840
                error = Particle_setNormfac( self, valtuple );
 
841
        else if( strcmp( name, "obfac" ) == 0 )
 
842
                error = Particle_setObfac( self, valtuple );
 
843
        else if( strcmp( name, "randfac" ) == 0 )
 
844
                error = Particle_setRandfac( self, valtuple );
 
845
        else if( strcmp( name, "texfac" ) == 0 )
 
846
                error = Particle_setTexfac( self, valtuple );
 
847
        else if( strcmp( name, "randlife" ) == 0 )
 
848
                error = Particle_setRandlife( self, valtuple );
 
849
        else if( strcmp( name, "nabla" ) == 0 )
 
850
                error = Particle_setNabla( self, valtuple );
 
851
        else if( strcmp( name, "vectsize" ) == 0 )
 
852
                error = Particle_setVectsize( self, valtuple );
 
853
        else if( strcmp( name, "totpart" ) == 0 )
 
854
                error = Particle_setTotpart( self, valtuple );
 
855
        else if( strcmp( name, "seed" ) == 0 )
 
856
                error = Particle_setSeed( self, valtuple );
 
857
        else if( strcmp( name, "force" ) == 0 )
 
858
                error = Particle_setForce( self, valtuple );
 
859
        else if( strcmp( name, "mult" ) == 0 )
 
860
                error = Particle_setMult( self, valtuple );
 
861
        else if( strcmp( name, "life" ) == 0 )
 
862
                error = Particle_setLife( self, valtuple );
 
863
        else if( strcmp( name, "child" ) == 0 )
 
864
                error = Particle_setChild( self, valtuple );
 
865
        else if( strcmp( name, "mat" ) == 0 )
 
866
                error = Particle_setMat( self, valtuple );
 
867
        else if( strcmp( name, "defvec" ) == 0 )
 
868
                error = Particle_setDefvec( self, valtuple );
 
869
 
 
870
        else {
 
871
                Py_DECREF( valtuple );
 
872
 
 
873
                if( ( strcmp( name, "Types" ) == 0 ) ||
 
874
                    ( strcmp( name, "Modes" ) == 0 ) )
 
875
                        return ( EXPP_ReturnIntError( PyExc_AttributeError,
 
876
                                                      "constant dictionary -- cannot be changed" ) );
 
877
 
 
878
                else
 
879
                        return ( EXPP_ReturnIntError( PyExc_KeyError,
 
880
                                                      "attribute not found" ) );
 
881
        }
 
882
 
 
883
        /*Py_DECREF(valtuple); */
 
884
        if( error != Py_None )
 
885
                return -1;
 
886
 
 
887
        Py_DECREF( Py_None );
 
888
        return 0;
853
889
}
854
890
 
855
891
/*****************************************************************************/
856
892
/* Function:    ParticlePrint                                                */
857
 
/* Description: This is a callback function for the BPy_Particle type. It      */
 
893
/* Description: This is a callback function for the BPy_Particle type. It    */
858
894
/*              particles a meaninful string to 'print' particle objects.    */
859
895
/*****************************************************************************/
860
896
/*
866
902
*/
867
903
/*****************************************************************************/
868
904
/* Function:    ParticleRepr                                                 */
869
 
/* Description: This is a callback function for the BPy_Particle type. It      */
 
905
/* Description: This is a callback function for the BPy_Particle type. It    */
870
906
/*              particles a meaninful string to represent particle objects.  */
871
907
/*****************************************************************************/
872
 
PyObject *ParticleRepr (BPy_Particle *self) 
 
908
PyObject *ParticleRepr( BPy_Particle * self )
873
909
{
874
 
        return PyString_FromString("Particle");
 
910
        return PyString_FromString( "Particle" );
875
911
}
876
912
 
877
 
PyObject* ParticleCreatePyObject (struct Effect *particle)
 
913
PyObject *ParticleCreatePyObject( struct Effect * particle )
878
914
{
879
 
        BPy_Particle    * blen_object;
880
 
 
881
 
 
882
 
        blen_object = (BPy_Particle*)PyObject_NEW (BPy_Particle, &Particle_Type);
883
 
 
884
 
        if (blen_object == NULL)
885
 
    {
886
 
                        return (NULL);
887
 
    }
 
915
        BPy_Particle *blen_object;
 
916
 
 
917
 
 
918
        blen_object =
 
919
                ( BPy_Particle * ) PyObject_NEW( BPy_Particle,
 
920
                                                 &Particle_Type );
 
921
 
 
922
        if( blen_object == NULL ) {
 
923
                return ( NULL );
 
924
        }
888
925
        blen_object->particle = particle;
889
 
        return ((PyObject*)blen_object);
890
 
 
891
 
}
892
 
 
893
 
int ParticleCheckPyObject (PyObject *py_obj)
894
 
{
895
 
        return (py_obj->ob_type == &Particle_Type);
896
 
}
897
 
 
898
 
 
899
 
struct Particle* ParticleFromPyObject (PyObject *py_obj)
900
 
{
901
 
        BPy_Particle    * blen_obj;
902
 
 
903
 
        blen_obj = (BPy_Particle*)py_obj;
904
 
        return ((struct Particle*)blen_obj->particle);
905
 
 
906
 
}
907
 
 
 
926
        return ( ( PyObject * ) blen_object );
 
927
 
 
928
}
 
929
 
 
930
int ParticleCheckPyObject( PyObject * py_obj )
 
931
{
 
932
        return ( py_obj->ob_type == &Particle_Type );
 
933
}
 
934
 
 
935
 
 
936
struct Particle *ParticleFromPyObject( PyObject * py_obj )
 
937
{
 
938
        BPy_Particle *blen_obj;
 
939
 
 
940
        blen_obj = ( BPy_Particle * ) py_obj;
 
941
        return ( ( struct Particle * ) blen_obj->particle );
 
942
 
 
943
}