← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Externals/MayaDataModel/include/MayaDMFlow.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/MayaDMFlow.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_FLOW_H__
 
11
#define __MayaDM_FLOW_H__
 
12
#include "MayaDMTypes.h"
 
13
#include "MayaDMConnectables.h"
 
14
#include "MayaDMDependNode.h"
 
15
namespace MayaDM
 
16
{
 
17
class Flow : public DependNode
 
18
{
 
19
public:
 
20
public:
 
21
 
 
22
        Flow():DependNode(){}
 
23
        Flow(FILE* file,const std::string& name,const std::string& parent="",bool shared=false,bool create=true)
 
24
                :DependNode(file, name, parent, "flow", shared, create){}
 
25
        virtual ~Flow(){}
 
26
 
 
27
        void setLatticeOnObject(bool lo)
 
28
        {
 
29
                if(lo == false) return;
 
30
                fprintf(mFile,"\tsetAttr \".lo\" %i;\n", lo);
 
31
        }
 
32
        void setParmValue(double pv)
 
33
        {
 
34
                if(pv == 0) return;
 
35
                fprintf(mFile,"\tsetAttr \".pv\" %f;\n", pv);
 
36
        }
 
37
        void setSDivisions(short sdv)
 
38
        {
 
39
                if(sdv == 2) return;
 
40
                fprintf(mFile,"\tsetAttr \".sdv\" %i;\n", sdv);
 
41
        }
 
42
        void setTDivisions(short tdv)
 
43
        {
 
44
                if(tdv == 5) return;
 
45
                fprintf(mFile,"\tsetAttr \".tdv\" %i;\n", tdv);
 
46
        }
 
47
        void setUDivisions(short udv)
 
48
        {
 
49
                if(udv == 2) return;
 
50
                fprintf(mFile,"\tsetAttr \".udv\" %i;\n", udv);
 
51
        }
 
52
        void setInBaseMatrix(const matrix& ibm)
 
53
        {
 
54
                if(ibm == identity) return;
 
55
                fprintf(mFile,"\tsetAttr \".ibm\" -type \"matrix\" ");
 
56
                ibm.write(mFile);
 
57
                fprintf(mFile,";\n");
 
58
        }
 
59
        void setDefMatrixInv(const matrix& dmi)
 
60
        {
 
61
                if(dmi == identity) return;
 
62
                fprintf(mFile,"\tsetAttr \".dmi\" -type \"matrix\" ");
 
63
                dmi.write(mFile);
 
64
                fprintf(mFile,";\n");
 
65
        }
 
66
        void setSetFrontAxis(unsigned int sfa)
 
67
        {
 
68
                if(sfa == 1) return;
 
69
                fprintf(mFile,"\tsetAttr \".sfa\" %i;\n", sfa);
 
70
        }
 
71
        void setSetUpAxis(unsigned int sua)
 
72
        {
 
73
                if(sua == 2) return;
 
74
                fprintf(mFile,"\tsetAttr \".sua\" %i;\n", sua);
 
75
        }
 
76
        void setOrientMatrix(const matrix& omx)
 
77
        {
 
78
                if(omx == identity) return;
 
79
                fprintf(mFile,"\tsetAttr \".omx\" -type \"matrix\" ");
 
80
                omx.write(mFile);
 
81
                fprintf(mFile,";\n");
 
82
        }
 
83
        void setAllCoords(const double3& ac)
 
84
        {
 
85
                if(ac == double3(0.0, 0.0, 0.0)) return;
 
86
                fprintf(mFile,"\tsetAttr \".ac\" -type \"double3\" ");
 
87
                ac.write(mFile);
 
88
                fprintf(mFile,";\n");
 
89
        }
 
90
        void setXCoord(double xc)
 
91
        {
 
92
                if(xc == 0) return;
 
93
                fprintf(mFile,"\tsetAttr \".ac.xc\" %f;\n", xc);
 
94
        }
 
95
        void setYCoord(double yc)
 
96
        {
 
97
                if(yc == 0) return;
 
98
                fprintf(mFile,"\tsetAttr \".ac.yc\" %f;\n", yc);
 
99
        }
 
100
        void setZCoord(double zc)
 
101
        {
 
102
                if(zc == 0) return;
 
103
                fprintf(mFile,"\tsetAttr \".ac.zc\" %f;\n", zc);
 
104
        }
 
105
        void setCenter(size_t ctr_i,const double3& ctr)
 
106
        {
 
107
                if(ctr == double3(0.0, 0.0, 0.0)) return;
 
108
                fprintf(mFile,"\tsetAttr \".ctr[%i]\" -type \"double3\" ",ctr_i);
 
109
                ctr.write(mFile);
 
110
                fprintf(mFile,";\n");
 
111
        }
 
112
        void setCenter(size_t ctr_start,size_t ctr_end,double* ctr)
 
113
        {
 
114
                fprintf(mFile,"\tsetAttr \".ctr[%i:%i]\" ", ctr_start,ctr_end);
 
115
                size_t size = (ctr_end-ctr_start)*3+3;
 
116
                for(size_t i=0;i<size;++i)
 
117
                {
 
118
                        fprintf(mFile,"%f",ctr[i]);
 
119
                        if(i+1<size) fprintf(mFile," ");
 
120
                }
 
121
                fprintf(mFile,";\n");
 
122
        }
 
123
        void startCenter(size_t ctr_start,size_t ctr_end)const
 
124
        {
 
125
                fprintf(mFile,"\tsetAttr \".ctr[%i:%i]\"",ctr_start,ctr_end);
 
126
        }
 
127
        void appendCenter(double ctr)const
 
128
        {
 
129
                fprintf(mFile," %f",ctr);
 
130
        }
 
131
        void endCenter()const
 
132
        {
 
133
                fprintf(mFile,";\n");
 
134
        }
 
135
        void setCenterX(size_t ctr_i,double ctx)
 
136
        {
 
137
                if(ctx == 0) return;
 
138
                fprintf(mFile,"\tsetAttr \".ctr[%i].ctx\" %f;\n", ctr_i,ctx);
 
139
        }
 
140
        void setCenterY(size_t ctr_i,double cty)
 
141
        {
 
142
                if(cty == 0) return;
 
143
                fprintf(mFile,"\tsetAttr \".ctr[%i].cty\" %f;\n", ctr_i,cty);
 
144
        }
 
145
        void setCenterZ(size_t ctr_i,double ctz)
 
146
        {
 
147
                if(ctz == 0) return;
 
148
                fprintf(mFile,"\tsetAttr \".ctr[%i].ctz\" %f;\n", ctr_i,ctz);
 
149
        }
 
150
        void setObjectWorldMatrix(size_t owmx_i,const matrix& owmx)
 
151
        {
 
152
                if(owmx == identity) return;
 
153
                fprintf(mFile,"\tsetAttr \".owmx[%i]\" -type \"matrix\" ",owmx_i);
 
154
                owmx.write(mFile);
 
155
                fprintf(mFile,";\n");
 
156
        }
 
157
        void setObjectWorldMatrix(size_t owmx_start,size_t owmx_end,matrix* owmx)
 
158
        {
 
159
                fprintf(mFile,"\tsetAttr \".owmx[%i:%i]\" ", owmx_start,owmx_end);
 
160
                size_t size = (owmx_end-owmx_start)*1+1;
 
161
                for(size_t i=0;i<size;++i)
 
162
                {
 
163
                        owmx[i].write(mFile);
 
164
                        fprintf(mFile,"\n");
 
165
                }
 
166
                fprintf(mFile,";\n");
 
167
        }
 
168
        void startObjectWorldMatrix(size_t owmx_start,size_t owmx_end)const
 
169
        {
 
170
                fprintf(mFile,"\tsetAttr \".owmx[%i:%i]\"",owmx_start,owmx_end);
 
171
                fprintf(mFile," -type \"matrix\" ");
 
172
        }
 
173
        void appendObjectWorldMatrix(const matrix& owmx)const
 
174
        {
 
175
                fprintf(mFile," ");
 
176
                owmx.write(mFile);
 
177
        }
 
178
        void endObjectWorldMatrix()const
 
179
        {
 
180
                fprintf(mFile,";\n");
 
181
        }
 
182
        void getMotionPath()const
 
183
        {
 
184
                fprintf(mFile,"\"%s.mp\"",mName.c_str());
 
185
        }
 
186
        void getCurve()const
 
187
        {
 
188
                fprintf(mFile,"\"%s.crv\"",mName.c_str());
 
189
        }
 
190
        void getParmValue()const
 
191
        {
 
192
                fprintf(mFile,"\"%s.pv\"",mName.c_str());
 
193
        }
 
194
        void getSDivisions()const
 
195
        {
 
196
                fprintf(mFile,"\"%s.sdv\"",mName.c_str());
 
197
        }
 
198
        void getTDivisions()const
 
199
        {
 
200
                fprintf(mFile,"\"%s.tdv\"",mName.c_str());
 
201
        }
 
202
        void getUDivisions()const
 
203
        {
 
204
                fprintf(mFile,"\"%s.udv\"",mName.c_str());
 
205
        }
 
206
        void getInBaseMatrix()const
 
207
        {
 
208
                fprintf(mFile,"\"%s.ibm\"",mName.c_str());
 
209
        }
 
210
        void getDefMatrixInv()const
 
211
        {
 
212
                fprintf(mFile,"\"%s.dmi\"",mName.c_str());
 
213
        }
 
214
        void getSetFrontAxis()const
 
215
        {
 
216
                fprintf(mFile,"\"%s.sfa\"",mName.c_str());
 
217
        }
 
218
        void getSetUpAxis()const
 
219
        {
 
220
                fprintf(mFile,"\"%s.sua\"",mName.c_str());
 
221
        }
 
222
        void getOrientMatrix()const
 
223
        {
 
224
                fprintf(mFile,"\"%s.omx\"",mName.c_str());
 
225
        }
 
226
        void getAllCoords()const
 
227
        {
 
228
                fprintf(mFile,"\"%s.ac\"",mName.c_str());
 
229
        }
 
230
        void getXCoord()const
 
231
        {
 
232
                fprintf(mFile,"\"%s.ac.xc\"",mName.c_str());
 
233
        }
 
234
        void getYCoord()const
 
235
        {
 
236
                fprintf(mFile,"\"%s.ac.yc\"",mName.c_str());
 
237
        }
 
238
        void getZCoord()const
 
239
        {
 
240
                fprintf(mFile,"\"%s.ac.zc\"",mName.c_str());
 
241
        }
 
242
        void getCenter(size_t ctr_i)const
 
243
        {
 
244
                fprintf(mFile,"\"%s.ctr[%i]\"",mName.c_str(),ctr_i);
 
245
        }
 
246
        void getCenter()const
 
247
        {
 
248
 
 
249
                fprintf(mFile,"\"%s.ctr\"",mName.c_str());
 
250
        }
 
251
        void getCenterX(size_t ctr_i)const
 
252
        {
 
253
                fprintf(mFile,"\"%s.ctr[%i].ctx\"",mName.c_str(),ctr_i);
 
254
        }
 
255
        void getCenterX()const
 
256
        {
 
257
 
 
258
                fprintf(mFile,"\"%s.ctr.ctx\"",mName.c_str());
 
259
        }
 
260
        void getCenterY(size_t ctr_i)const
 
261
        {
 
262
                fprintf(mFile,"\"%s.ctr[%i].cty\"",mName.c_str(),ctr_i);
 
263
        }
 
264
        void getCenterY()const
 
265
        {
 
266
 
 
267
                fprintf(mFile,"\"%s.ctr.cty\"",mName.c_str());
 
268
        }
 
269
        void getCenterZ(size_t ctr_i)const
 
270
        {
 
271
                fprintf(mFile,"\"%s.ctr[%i].ctz\"",mName.c_str(),ctr_i);
 
272
        }
 
273
        void getCenterZ()const
 
274
        {
 
275
 
 
276
                fprintf(mFile,"\"%s.ctr.ctz\"",mName.c_str());
 
277
        }
 
278
        void getObjectWorldMatrix(size_t owmx_i)const
 
279
        {
 
280
                fprintf(mFile,"\"%s.owmx[%i]\"",mName.c_str(),owmx_i);
 
281
        }
 
282
        void getObjectWorldMatrix()const
 
283
        {
 
284
 
 
285
                fprintf(mFile,"\"%s.owmx\"",mName.c_str());
 
286
        }
 
287
        void getOutBaseMatrix()const
 
288
        {
 
289
                fprintf(mFile,"\"%s.obm\"",mName.c_str());
 
290
        }
 
291
        void getDefPts()const
 
292
        {
 
293
                fprintf(mFile,"\"%s.dpt\"",mName.c_str());
 
294
        }
 
295
protected:
 
296
        Flow(FILE* file,const std::string& name,const std::string& parent,const std::string& nodeType,bool shared=false,bool create=true)
 
297
                :DependNode(file, name, parent, nodeType, shared, create) {}
 
298
 
 
299
};
 
300
}//namespace MayaDM
 
301
#endif//__MayaDM_FLOW_H__