← Back to branch summary

~ubuntu-branches/ubuntu/wily/opencollada/wily-proposed

« back to all changes in this revision

Viewing changes to Externals/MayaDataModel/include/MayaDMSpring.h

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2015-05-14 17:23:27 UTC
  • Revision ID: package-import@ubuntu.com-20150514172327-f862u8envms01fra
Tags: upstream-0.1.0~20140703.ddf8f47+dfsg1
Import upstream version 0.1.0~20140703.ddf8f47+dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Externals/MayaDataModel/include/MayaDMSpring.h
 
1
/*
 
2
    Copyright (c) 2008-2009 NetAllied Systems GmbH
 
3
 
 
4
    This file is part of MayaDataModel.
 
5
 
 
6
    Licensed under the MIT Open Source License,
 
7
    for details please see LICENSE file or the website
 
8
    http://www.opensource.org/licenses/mit-license.php
 
9
*/
 
10
#ifndef __MayaDM_SPRING_H__
 
11
#define __MayaDM_SPRING_H__
 
12
#include "MayaDMTypes.h"
 
13
#include "MayaDMConnectables.h"
 
14
#include "MayaDMShape.h"
 
15
namespace MayaDM
 
16
{
 
17
class Spring : public Shape
 
18
{
 
19
public:
 
20
        struct IdMapping{
 
21
                void write(FILE* file) const
 
22
                {
 
23
                }
 
24
        };
 
25
public:
 
26
 
 
27
        Spring():Shape(){}
 
28
        Spring(FILE* file,const std::string& name,const std::string& parent="",bool shared=false,bool create=true)
 
29
                :Shape(file, name, parent, "spring", shared, create){}
 
30
        virtual ~Spring(){}
 
31
 
 
32
        void setEnd1Weight(double f)
 
33
        {
 
34
                if(f == 1) return;
 
35
                fprintf(mFile,"\tsetAttr \".f\" %f;\n", f);
 
36
        }
 
37
        void setEnd2Weight(double t)
 
38
        {
 
39
                if(t == 1) return;
 
40
                fprintf(mFile,"\tsetAttr \".t\" %f;\n", t);
 
41
        }
 
42
        void setUseStiffnessPS(bool usps)
 
43
        {
 
44
                if(usps == true) return;
 
45
                fprintf(mFile,"\tsetAttr \".usps\" %i;\n", usps);
 
46
        }
 
47
        void setUseDampingPS(bool udps)
 
48
        {
 
49
                if(udps == true) return;
 
50
                fprintf(mFile,"\tsetAttr \".udps\" %i;\n", udps);
 
51
        }
 
52
        void setUseRestLengthPS(bool urps)
 
53
        {
 
54
                if(urps == true) return;
 
55
                fprintf(mFile,"\tsetAttr \".urps\" %i;\n", urps);
 
56
        }
 
57
        void setStiffness(double s)
 
58
        {
 
59
                if(s == 1) return;
 
60
                fprintf(mFile,"\tsetAttr \".s\" %f;\n", s);
 
61
        }
 
62
        void setDamping(double d)
 
63
        {
 
64
                if(d == .2) return;
 
65
                fprintf(mFile,"\tsetAttr \".d\" %f;\n", d);
 
66
        }
 
67
        void setRestLength(double r)
 
68
        {
 
69
                if(r == 0) return;
 
70
                fprintf(mFile,"\tsetAttr \".r\" %f;\n", r);
 
71
        }
 
72
        void setStiffnessPS(const doubleArray& sps)
 
73
        {
 
74
                if(sps.size == 0) return;
 
75
                fprintf(mFile,"\tsetAttr \".sps\" -type \"doubleArray\" ");
 
76
                sps.write(mFile);
 
77
                fprintf(mFile,";\n");
 
78
        }
 
79
        void setDampingPS(const doubleArray& dps)
 
80
        {
 
81
                if(dps.size == 0) return;
 
82
                fprintf(mFile,"\tsetAttr \".dps\" -type \"doubleArray\" ");
 
83
                dps.write(mFile);
 
84
                fprintf(mFile,";\n");
 
85
        }
 
86
        void setRestLengthPS(const doubleArray& rps)
 
87
        {
 
88
                if(rps.size == 0) return;
 
89
                fprintf(mFile,"\tsetAttr \".rps\" -type \"doubleArray\" ");
 
90
                rps.write(mFile);
 
91
                fprintf(mFile,";\n");
 
92
        }
 
93
        void setObjectPositions(size_t opos_i,const vectorArray& opos)
 
94
        {
 
95
                if(opos.size == 0) return;
 
96
                fprintf(mFile,"\tsetAttr \".opos[%i]\" -type \"vectorArray\" ",opos_i);
 
97
                opos.write(mFile);
 
98
                fprintf(mFile,";\n");
 
99
        }
 
100
        void setObjectPositions(size_t opos_start,size_t opos_end,vectorArray* opos)
 
101
        {
 
102
                fprintf(mFile,"\tsetAttr \".opos[%i:%i]\" ", opos_start,opos_end);
 
103
                size_t size = (opos_end-opos_start)*1+1;
 
104
                for(size_t i=0;i<size;++i)
 
105
                {
 
106
                        opos[i].write(mFile);
 
107
                        fprintf(mFile,"\n");
 
108
                }
 
109
                fprintf(mFile,";\n");
 
110
        }
 
111
        void startObjectPositions(size_t opos_start,size_t opos_end)const
 
112
        {
 
113
                fprintf(mFile,"\tsetAttr \".opos[%i:%i]\"",opos_start,opos_end);
 
114
                fprintf(mFile," -type \"vectorArray\" ");
 
115
        }
 
116
        void appendObjectPositions(const vectorArray& opos)const
 
117
        {
 
118
                fprintf(mFile," ");
 
119
                opos.write(mFile);
 
120
        }
 
121
        void endObjectPositions()const
 
122
        {
 
123
                fprintf(mFile,";\n");
 
124
        }
 
125
        void setObjectVelocities(size_t ovel_i,const vectorArray& ovel)
 
126
        {
 
127
                if(ovel.size == 0) return;
 
128
                fprintf(mFile,"\tsetAttr \".ovel[%i]\" -type \"vectorArray\" ",ovel_i);
 
129
                ovel.write(mFile);
 
130
                fprintf(mFile,";\n");
 
131
        }
 
132
        void setObjectVelocities(size_t ovel_start,size_t ovel_end,vectorArray* ovel)
 
133
        {
 
134
                fprintf(mFile,"\tsetAttr \".ovel[%i:%i]\" ", ovel_start,ovel_end);
 
135
                size_t size = (ovel_end-ovel_start)*1+1;
 
136
                for(size_t i=0;i<size;++i)
 
137
                {
 
138
                        ovel[i].write(mFile);
 
139
                        fprintf(mFile,"\n");
 
140
                }
 
141
                fprintf(mFile,";\n");
 
142
        }
 
143
        void startObjectVelocities(size_t ovel_start,size_t ovel_end)const
 
144
        {
 
145
                fprintf(mFile,"\tsetAttr \".ovel[%i:%i]\"",ovel_start,ovel_end);
 
146
                fprintf(mFile," -type \"vectorArray\" ");
 
147
        }
 
148
        void appendObjectVelocities(const vectorArray& ovel)const
 
149
        {
 
150
                fprintf(mFile," ");
 
151
                ovel.write(mFile);
 
152
        }
 
153
        void endObjectVelocities()const
 
154
        {
 
155
                fprintf(mFile,";\n");
 
156
        }
 
157
        void setObjectMass(size_t omas_i,const doubleArray& omas)
 
158
        {
 
159
                if(omas.size == 0) return;
 
160
                fprintf(mFile,"\tsetAttr \".omas[%i]\" -type \"doubleArray\" ",omas_i);
 
161
                omas.write(mFile);
 
162
                fprintf(mFile,";\n");
 
163
        }
 
164
        void setObjectMass(size_t omas_start,size_t omas_end,doubleArray* omas)
 
165
        {
 
166
                fprintf(mFile,"\tsetAttr \".omas[%i:%i]\" ", omas_start,omas_end);
 
167
                size_t size = (omas_end-omas_start)*1+1;
 
168
                for(size_t i=0;i<size;++i)
 
169
                {
 
170
                        omas[i].write(mFile);
 
171
                        fprintf(mFile,"\n");
 
172
                }
 
173
                fprintf(mFile,";\n");
 
174
        }
 
175
        void startObjectMass(size_t omas_start,size_t omas_end)const
 
176
        {
 
177
                fprintf(mFile,"\tsetAttr \".omas[%i:%i]\"",omas_start,omas_end);
 
178
                fprintf(mFile," -type \"doubleArray\" ");
 
179
        }
 
180
        void appendObjectMass(const doubleArray& omas)const
 
181
        {
 
182
                fprintf(mFile," ");
 
183
                omas.write(mFile);
 
184
        }
 
185
        void endObjectMass()const
 
186
        {
 
187
                fprintf(mFile,";\n");
 
188
        }
 
189
        void setDeltaTime(size_t dt_i,double dt)
 
190
        {
 
191
                if(dt == 0) return;
 
192
                fprintf(mFile,"\tsetAttr \".dt[%i]\" %f;\n", dt_i,dt);
 
193
        }
 
194
        void setDeltaTime(size_t dt_start,size_t dt_end,double* dt)
 
195
        {
 
196
                fprintf(mFile,"\tsetAttr \".dt[%i:%i]\" ", dt_start,dt_end);
 
197
                size_t size = (dt_end-dt_start)*1+1;
 
198
                for(size_t i=0;i<size;++i)
 
199
                {
 
200
                        fprintf(mFile,"%f",dt[i]);
 
201
                        if(i+1<size) fprintf(mFile," ");
 
202
                }
 
203
                fprintf(mFile,";\n");
 
204
        }
 
205
        void startDeltaTime(size_t dt_start,size_t dt_end)const
 
206
        {
 
207
                fprintf(mFile,"\tsetAttr \".dt[%i:%i]\"",dt_start,dt_end);
 
208
        }
 
209
        void appendDeltaTime(double dt)const
 
210
        {
 
211
                fprintf(mFile," %f",dt);
 
212
        }
 
213
        void endDeltaTime()const
 
214
        {
 
215
                fprintf(mFile,";\n");
 
216
        }
 
217
        void setValidIndex(const intArray& vali)
 
218
        {
 
219
                if(vali.size == 0) return;
 
220
                fprintf(mFile,"\tsetAttr \".vali\" -type \"intArray\" ");
 
221
                vali.write(mFile);
 
222
                fprintf(mFile,";\n");
 
223
        }
 
224
        void setObject0(const intArray& obz)
 
225
        {
 
226
                if(obz.size == 0) return;
 
227
                fprintf(mFile,"\tsetAttr \".obz\" -type \"intArray\" ");
 
228
                obz.write(mFile);
 
229
                fprintf(mFile,";\n");
 
230
        }
 
231
        void setPoint0(const intArray& ptz)
 
232
        {
 
233
                if(ptz.size == 0) return;
 
234
                fprintf(mFile,"\tsetAttr \".ptz\" -type \"intArray\" ");
 
235
                ptz.write(mFile);
 
236
                fprintf(mFile,";\n");
 
237
        }
 
238
        void setObject1(const intArray& obo)
 
239
        {
 
240
                if(obo.size == 0) return;
 
241
                fprintf(mFile,"\tsetAttr \".obo\" -type \"intArray\" ");
 
242
                obo.write(mFile);
 
243
                fprintf(mFile,";\n");
 
244
        }
 
245
        void setPoint1(const intArray& pto)
 
246
        {
 
247
                if(pto.size == 0) return;
 
248
                fprintf(mFile,"\tsetAttr \".pto\" -type \"intArray\" ");
 
249
                pto.write(mFile);
 
250
                fprintf(mFile,";\n");
 
251
        }
 
252
        void setMinSprings(int ms)
 
253
        {
 
254
                if(ms == 0) return;
 
255
                fprintf(mFile,"\tsetAttr \".ms\" %i;\n", ms);
 
256
        }
 
257
        void setManageParticleDeath(bool mpd)
 
258
        {
 
259
                if(mpd == true) return;
 
260
                fprintf(mFile,"\tsetAttr \".mpd\" %i;\n", mpd);
 
261
        }
 
262
        void setLengths(const doubleArray& lns)
 
263
        {
 
264
                if(lns.size == 0) return;
 
265
                fprintf(mFile,"\tsetAttr \".lns\" -type \"doubleArray\" ");
 
266
                lns.write(mFile);
 
267
                fprintf(mFile,";\n");
 
268
        }
 
269
        void getEnd1Weight()const
 
270
        {
 
271
                fprintf(mFile,"\"%s.f\"",mName.c_str());
 
272
        }
 
273
        void getEnd2Weight()const
 
274
        {
 
275
                fprintf(mFile,"\"%s.t\"",mName.c_str());
 
276
        }
 
277
        void getStiffness()const
 
278
        {
 
279
                fprintf(mFile,"\"%s.s\"",mName.c_str());
 
280
        }
 
281
        void getDamping()const
 
282
        {
 
283
                fprintf(mFile,"\"%s.d\"",mName.c_str());
 
284
        }
 
285
        void getRestLength()const
 
286
        {
 
287
                fprintf(mFile,"\"%s.r\"",mName.c_str());
 
288
        }
 
289
        void getStiffnessPS()const
 
290
        {
 
291
                fprintf(mFile,"\"%s.sps\"",mName.c_str());
 
292
        }
 
293
        void getDampingPS()const
 
294
        {
 
295
                fprintf(mFile,"\"%s.dps\"",mName.c_str());
 
296
        }
 
297
        void getRestLengthPS()const
 
298
        {
 
299
                fprintf(mFile,"\"%s.rps\"",mName.c_str());
 
300
        }
 
301
        void getObjectPositions(size_t opos_i)const
 
302
        {
 
303
                fprintf(mFile,"\"%s.opos[%i]\"",mName.c_str(),opos_i);
 
304
        }
 
305
        void getObjectPositions()const
 
306
        {
 
307
 
 
308
                fprintf(mFile,"\"%s.opos\"",mName.c_str());
 
309
        }
 
310
        void getObjectVelocities(size_t ovel_i)const
 
311
        {
 
312
                fprintf(mFile,"\"%s.ovel[%i]\"",mName.c_str(),ovel_i);
 
313
        }
 
314
        void getObjectVelocities()const
 
315
        {
 
316
 
 
317
                fprintf(mFile,"\"%s.ovel\"",mName.c_str());
 
318
        }
 
319
        void getObjectMass(size_t omas_i)const
 
320
        {
 
321
                fprintf(mFile,"\"%s.omas[%i]\"",mName.c_str(),omas_i);
 
322
        }
 
323
        void getObjectMass()const
 
324
        {
 
325
 
 
326
                fprintf(mFile,"\"%s.omas\"",mName.c_str());
 
327
        }
 
328
        void getDeltaTime(size_t dt_i)const
 
329
        {
 
330
                fprintf(mFile,"\"%s.dt[%i]\"",mName.c_str(),dt_i);
 
331
        }
 
332
        void getDeltaTime()const
 
333
        {
 
334
 
 
335
                fprintf(mFile,"\"%s.dt\"",mName.c_str());
 
336
        }
 
337
        void getOutputForce(size_t of_i)const
 
338
        {
 
339
                fprintf(mFile,"\"%s.of[%i]\"",mName.c_str(),of_i);
 
340
        }
 
341
        void getOutputForce()const
 
342
        {
 
343
 
 
344
                fprintf(mFile,"\"%s.of\"",mName.c_str());
 
345
        }
 
346
        void getIdMapping(size_t idm_i)const
 
347
        {
 
348
                fprintf(mFile,"\"%s.idm[%i]\"",mName.c_str(),idm_i);
 
349
        }
 
350
        void getIdMapping()const
 
351
        {
 
352
 
 
353
                fprintf(mFile,"\"%s.idm\"",mName.c_str());
 
354
        }
 
355
        void getSortedId(size_t idm_i)const
 
356
        {
 
357
                fprintf(mFile,"\"%s.idm[%i].sid\"",mName.c_str(),idm_i);
 
358
        }
 
359
        void getSortedId()const
 
360
        {
 
361
 
 
362
                fprintf(mFile,"\"%s.idm.sid\"",mName.c_str());
 
363
        }
 
364
        void getIdIndex(size_t idm_i)const
 
365
        {
 
366
                fprintf(mFile,"\"%s.idm[%i].idix\"",mName.c_str(),idm_i);
 
367
        }
 
368
        void getIdIndex()const
 
369
        {
 
370
 
 
371
                fprintf(mFile,"\"%s.idm.idix\"",mName.c_str());
 
372
        }
 
373
        void getCount()const
 
374
        {
 
375
                fprintf(mFile,"\"%s.cnt\"",mName.c_str());
 
376
        }
 
377
        void getObjects(size_t obj_i)const
 
378
        {
 
379
                fprintf(mFile,"\"%s.obj[%i]\"",mName.c_str(),obj_i);
 
380
        }
 
381
        void getObjects()const
 
382
        {
 
383
 
 
384
                fprintf(mFile,"\"%s.obj\"",mName.c_str());
 
385
        }
 
386
        void getObjCount()const
 
387
        {
 
388
                fprintf(mFile,"\"%s.obc\"",mName.c_str());
 
389
        }
 
390
        void getLengths()const
 
391
        {
 
392
                fprintf(mFile,"\"%s.lns\"",mName.c_str());
 
393
        }
 
394
        void getMinUsed()const
 
395
        {
 
396
                fprintf(mFile,"\"%s.mnu\"",mName.c_str());
 
397
        }
 
398
        void getMaxUsed()const
 
399
        {
 
400
                fprintf(mFile,"\"%s.mxu\"",mName.c_str());
 
401
        }
 
402
        void getPt0Index()const
 
403
        {
 
404
                fprintf(mFile,"\"%s.pzi\"",mName.c_str());
 
405
        }
 
406
        void getPt1Index()const
 
407
        {
 
408
                fprintf(mFile,"\"%s.poi\"",mName.c_str());
 
409
        }
 
410
        void getObj0Index()const
 
411
        {
 
412
                fprintf(mFile,"\"%s.ozi\"",mName.c_str());
 
413
        }
 
414
        void getObj1Index()const
 
415
        {
 
416
                fprintf(mFile,"\"%s.ooi\"",mName.c_str());
 
417
        }
 
418
protected:
 
419
        Spring(FILE* file,const std::string& name,const std::string& parent,const std::string& nodeType,bool shared=false,bool create=true)
 
420
                :Shape(file, name, parent, nodeType, shared, create) {}
 
421
 
 
422
};
 
423
}//namespace MayaDM
 
424
#endif//__MayaDM_SPRING_H__