← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Externals/MayaDataModel/include/MayaDMFile.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/MayaDMFile.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_FILE_H__
 
11
#define __MayaDM_FILE_H__
 
12
#include "MayaDMTypes.h"
 
13
#include "MayaDMConnectables.h"
 
14
#include "MayaDMTexture2d.h"
 
15
namespace MayaDM
 
16
{
 
17
class File : public Texture2d
 
18
{
 
19
public:
 
20
public:
 
21
 
 
22
        File():Texture2d(){}
 
23
        File(FILE* file,const std::string& name,const std::string& parent="",bool shared=false,bool create=true)
 
24
                :Texture2d(file, name, parent, "file", shared, create){}
 
25
        virtual ~File(){}
 
26
 
 
27
        void setFileTextureName(const string& ftn)
 
28
        {
 
29
                if(ftn == "NULL") return;
 
30
                fprintf(mFile,"\tsetAttr \".ftn\" -type \"string\" ");
 
31
                ftn.write(mFile);
 
32
                fprintf(mFile,";\n");
 
33
        }
 
34
        void setDisableFileLoad(bool dfl)
 
35
        {
 
36
                if(dfl == false) return;
 
37
                fprintf(mFile,"\tsetAttr \".dfl\" %i;\n", dfl);
 
38
        }
 
39
        void setUseFrameExtension(bool ufe)
 
40
        {
 
41
                if(ufe == false) return;
 
42
                fprintf(mFile,"\tsetAttr \".ufe\" %i;\n", ufe);
 
43
        }
 
44
        void setFrameExtension(int fe)
 
45
        {
 
46
                if(fe == 1) return;
 
47
                fprintf(mFile,"\tsetAttr \".fe\" %i;\n", fe);
 
48
        }
 
49
        void setFrameOffset(int io)
 
50
        {
 
51
                if(io == 0) return;
 
52
                fprintf(mFile,"\tsetAttr \".io\" %i;\n", io);
 
53
        }
 
54
        void setUseHardwareTextureCycling(bool uhc)
 
55
        {
 
56
                if(uhc == false) return;
 
57
                fprintf(mFile,"\tsetAttr \".uhc\" %i;\n", uhc);
 
58
        }
 
59
        void setStartCycleExtension(int sce)
 
60
        {
 
61
                if(sce == 1) return;
 
62
                fprintf(mFile,"\tsetAttr \".sce\" %i;\n", sce);
 
63
        }
 
64
        void setEndCycleExtension(int ece)
 
65
        {
 
66
                if(ece == 1) return;
 
67
                fprintf(mFile,"\tsetAttr \".ece\" %i;\n", ece);
 
68
        }
 
69
        void setByCycleIncrement(int bci)
 
70
        {
 
71
                if(bci == 1) return;
 
72
                fprintf(mFile,"\tsetAttr \".bci\" %i;\n", bci);
 
73
        }
 
74
        void setFilterType(unsigned int ft)
 
75
        {
 
76
                if(ft == 3) return;
 
77
                fprintf(mFile,"\tsetAttr \".ft\" %i;\n", ft);
 
78
        }
 
79
        void setFilterWidth(float fw)
 
80
        {
 
81
                if(fw == 0.707) return;
 
82
                fprintf(mFile,"\tsetAttr \".fw\" %f;\n", fw);
 
83
        }
 
84
        void setUseCache(bool uca)
 
85
        {
 
86
                if(uca == false) return;
 
87
                fprintf(mFile,"\tsetAttr \".uca\" %i;\n", uca);
 
88
        }
 
89
        void setUseMaximumRes(bool umr)
 
90
        {
 
91
                if(umr == false) return;
 
92
                fprintf(mFile,"\tsetAttr \".umr\" %i;\n", umr);
 
93
        }
 
94
        void setCoverage(const float2& c)
 
95
        {
 
96
                if(c == float2(1.0f,1.0f)) return;
 
97
                fprintf(mFile,"\tsetAttr \".c\" -type \"float2\" ");
 
98
                c.write(mFile);
 
99
                fprintf(mFile,";\n");
 
100
        }
 
101
        void setCoverageU(float cu)
 
102
        {
 
103
                if(cu == 0.0) return;
 
104
                fprintf(mFile,"\tsetAttr \".c.cu\" %f;\n", cu);
 
105
        }
 
106
        void setCoverageV(float cv)
 
107
        {
 
108
                if(cv == 0.0) return;
 
109
                fprintf(mFile,"\tsetAttr \".c.cv\" %f;\n", cv);
 
110
        }
 
111
        void setTranslateFrame(const float2& tf)
 
112
        {
 
113
                if(tf == float2(0.0f,0.0f)) return;
 
114
                fprintf(mFile,"\tsetAttr \".tf\" -type \"float2\" ");
 
115
                tf.write(mFile);
 
116
                fprintf(mFile,";\n");
 
117
        }
 
118
        void setTranslateFrameU(float tfu)
 
119
        {
 
120
                if(tfu == 0.0) return;
 
121
                fprintf(mFile,"\tsetAttr \".tf.tfu\" %f;\n", tfu);
 
122
        }
 
123
        void setTranslateFrameV(float tfv)
 
124
        {
 
125
                if(tfv == 0.0) return;
 
126
                fprintf(mFile,"\tsetAttr \".tf.tfv\" %f;\n", tfv);
 
127
        }
 
128
        void setRotateFrame(double rf)
 
129
        {
 
130
                if(rf == 0) return;
 
131
                fprintf(mFile,"\tsetAttr \".rf\" %f;\n", rf);
 
132
        }
 
133
        void setDoTransform(bool dtf)
 
134
        {
 
135
                if(dtf == true) return;
 
136
                fprintf(mFile,"\tsetAttr \".dtf\" %i;\n", dtf);
 
137
        }
 
138
        void setMirrorU(bool mu)
 
139
        {
 
140
                if(mu == false) return;
 
141
                fprintf(mFile,"\tsetAttr \".mu\" %i;\n", mu);
 
142
        }
 
143
        void setMirrorV(bool mv)
 
144
        {
 
145
                if(mv == false) return;
 
146
                fprintf(mFile,"\tsetAttr \".mv\" %i;\n", mv);
 
147
        }
 
148
        void setStagger(bool s)
 
149
        {
 
150
                if(s == false) return;
 
151
                fprintf(mFile,"\tsetAttr \".s\" %i;\n", s);
 
152
        }
 
153
        void setWrapU(bool wu)
 
154
        {
 
155
                if(wu == true) return;
 
156
                fprintf(mFile,"\tsetAttr \".wu\" %i;\n", wu);
 
157
        }
 
158
        void setWrapV(bool wv)
 
159
        {
 
160
                if(wv == true) return;
 
161
                fprintf(mFile,"\tsetAttr \".wv\" %i;\n", wv);
 
162
        }
 
163
        void setRepeatUV(const float2& re)
 
164
        {
 
165
                if(re == float2(1.0f,1.0f)) return;
 
166
                fprintf(mFile,"\tsetAttr \".re\" -type \"float2\" ");
 
167
                re.write(mFile);
 
168
                fprintf(mFile,";\n");
 
169
        }
 
170
        void setRepeatU(float reu)
 
171
        {
 
172
                if(reu == 0.0) return;
 
173
                fprintf(mFile,"\tsetAttr \".re.reu\" %f;\n", reu);
 
174
        }
 
175
        void setRepeatV(float rev)
 
176
        {
 
177
                if(rev == 0.0) return;
 
178
                fprintf(mFile,"\tsetAttr \".re.rev\" %f;\n", rev);
 
179
        }
 
180
        void setOffset(const float2& of)
 
181
        {
 
182
                if(of == float2(0.0f,0.0f)) return;
 
183
                fprintf(mFile,"\tsetAttr \".of\" -type \"float2\" ");
 
184
                of.write(mFile);
 
185
                fprintf(mFile,";\n");
 
186
        }
 
187
        void setOffsetU(float ofu)
 
188
        {
 
189
                if(ofu == 0.0) return;
 
190
                fprintf(mFile,"\tsetAttr \".of.ofu\" %f;\n", ofu);
 
191
        }
 
192
        void setOffsetV(float ofv)
 
193
        {
 
194
                if(ofv == 0.0) return;
 
195
                fprintf(mFile,"\tsetAttr \".of.ofv\" %f;\n", ofv);
 
196
        }
 
197
        void setRotateUV(double ro)
 
198
        {
 
199
                if(ro == 0) return;
 
200
                fprintf(mFile,"\tsetAttr \".ro\" %f;\n", ro);
 
201
        }
 
202
        void setNoiseUV(const float2& n)
 
203
        {
 
204
                if(n == float2(0.0f,0.0f)) return;
 
205
                fprintf(mFile,"\tsetAttr \".n\" -type \"float2\" ");
 
206
                n.write(mFile);
 
207
                fprintf(mFile,";\n");
 
208
        }
 
209
        void setNoiseU(float nu)
 
210
        {
 
211
                if(nu == 0.0) return;
 
212
                fprintf(mFile,"\tsetAttr \".n.nu\" %f;\n", nu);
 
213
        }
 
214
        void setNoiseV(float nv)
 
215
        {
 
216
                if(nv == 0.0) return;
 
217
                fprintf(mFile,"\tsetAttr \".n.nv\" %f;\n", nv);
 
218
        }
 
219
        void setBlurPixelation(bool blp)
 
220
        {
 
221
                if(blp == true) return;
 
222
                fprintf(mFile,"\tsetAttr \".blp\" %i;\n", blp);
 
223
        }
 
224
        void setVertexCameraOne(const float3& vc1)
 
225
        {
 
226
                fprintf(mFile,"\tsetAttr \".vc1\" -type \"float3\" ");
 
227
                vc1.write(mFile);
 
228
                fprintf(mFile,";\n");
 
229
        }
 
230
        void setVertexCameraOneX(float c1x)
 
231
        {
 
232
                if(c1x == 0.0) return;
 
233
                fprintf(mFile,"\tsetAttr \".vc1.c1x\" %f;\n", c1x);
 
234
        }
 
235
        void setVertexCameraOneY(float c1y)
 
236
        {
 
237
                if(c1y == 0.0) return;
 
238
                fprintf(mFile,"\tsetAttr \".vc1.c1y\" %f;\n", c1y);
 
239
        }
 
240
        void setVertexCameraOneZ(float c1z)
 
241
        {
 
242
                if(c1z == 0.0) return;
 
243
                fprintf(mFile,"\tsetAttr \".vc1.c1z\" %f;\n", c1z);
 
244
        }
 
245
        void setVertexCameraTwo(const float3& vc2)
 
246
        {
 
247
                fprintf(mFile,"\tsetAttr \".vc2\" -type \"float3\" ");
 
248
                vc2.write(mFile);
 
249
                fprintf(mFile,";\n");
 
250
        }
 
251
        void setVertexCameraTwoX(float c2x)
 
252
        {
 
253
                if(c2x == 0.0) return;
 
254
                fprintf(mFile,"\tsetAttr \".vc2.c2x\" %f;\n", c2x);
 
255
        }
 
256
        void setVertexCameraTwoY(float c2y)
 
257
        {
 
258
                if(c2y == 0.0) return;
 
259
                fprintf(mFile,"\tsetAttr \".vc2.c2y\" %f;\n", c2y);
 
260
        }
 
261
        void setVertexCameraTwoZ(float c2z)
 
262
        {
 
263
                if(c2z == 0.0) return;
 
264
                fprintf(mFile,"\tsetAttr \".vc2.c2z\" %f;\n", c2z);
 
265
        }
 
266
        void setVertexCameraThree(const float3& vc3)
 
267
        {
 
268
                fprintf(mFile,"\tsetAttr \".vc3\" -type \"float3\" ");
 
269
                vc3.write(mFile);
 
270
                fprintf(mFile,";\n");
 
271
        }
 
272
        void setVertexCameraThreeX(float c3x)
 
273
        {
 
274
                if(c3x == 0.0) return;
 
275
                fprintf(mFile,"\tsetAttr \".vc3.c3x\" %f;\n", c3x);
 
276
        }
 
277
        void setVertexCameraThreeY(float c3y)
 
278
        {
 
279
                if(c3y == 0.0) return;
 
280
                fprintf(mFile,"\tsetAttr \".vc3.c3y\" %f;\n", c3y);
 
281
        }
 
282
        void setVertexCameraThreeZ(float c3z)
 
283
        {
 
284
                if(c3z == 0.0) return;
 
285
                fprintf(mFile,"\tsetAttr \".vc3.c3z\" %f;\n", c3z);
 
286
        }
 
287
        void setVertexUvOne(const float2& vt1)
 
288
        {
 
289
                fprintf(mFile,"\tsetAttr \".vt1\" -type \"float2\" ");
 
290
                vt1.write(mFile);
 
291
                fprintf(mFile,";\n");
 
292
        }
 
293
        void setVertexUvOneU(float t1u)
 
294
        {
 
295
                if(t1u == 0.0) return;
 
296
                fprintf(mFile,"\tsetAttr \".vt1.t1u\" %f;\n", t1u);
 
297
        }
 
298
        void setVertexUvOneV(float t1v)
 
299
        {
 
300
                if(t1v == 0.0) return;
 
301
                fprintf(mFile,"\tsetAttr \".vt1.t1v\" %f;\n", t1v);
 
302
        }
 
303
        void setVertexUvTwo(const float2& vt2)
 
304
        {
 
305
                fprintf(mFile,"\tsetAttr \".vt2\" -type \"float2\" ");
 
306
                vt2.write(mFile);
 
307
                fprintf(mFile,";\n");
 
308
        }
 
309
        void setVertexUvTwoU(float t2u)
 
310
        {
 
311
                if(t2u == 0.0) return;
 
312
                fprintf(mFile,"\tsetAttr \".vt2.t2u\" %f;\n", t2u);
 
313
        }
 
314
        void setVertexUvTwoV(float t2v)
 
315
        {
 
316
                if(t2v == 0.0) return;
 
317
                fprintf(mFile,"\tsetAttr \".vt2.t2v\" %f;\n", t2v);
 
318
        }
 
319
        void setVertexUvThree(const float2& vt3)
 
320
        {
 
321
                fprintf(mFile,"\tsetAttr \".vt3\" -type \"float2\" ");
 
322
                vt3.write(mFile);
 
323
                fprintf(mFile,";\n");
 
324
        }
 
325
        void setVertexUvThreeU(float t3u)
 
326
        {
 
327
                if(t3u == 0.0) return;
 
328
                fprintf(mFile,"\tsetAttr \".vt3.t3u\" %f;\n", t3u);
 
329
        }
 
330
        void setVertexUvThreeV(float t3v)
 
331
        {
 
332
                if(t3v == 0.0) return;
 
333
                fprintf(mFile,"\tsetAttr \".vt3.t3v\" %f;\n", t3v);
 
334
        }
 
335
        void setObjectType(char otp)
 
336
        {
 
337
                if(otp == 0) return;
 
338
                fprintf(mFile,"\tsetAttr \".otp\" %;\n", otp);
 
339
        }
 
340
        void setRayDepth(int rdp)
 
341
        {
 
342
                if(rdp == 0) return;
 
343
                fprintf(mFile,"\tsetAttr \".rdp\" %i;\n", rdp);
 
344
        }
 
345
        void setPixelCenter(const float2& pct)
 
346
        {
 
347
                fprintf(mFile,"\tsetAttr \".pct\" -type \"float2\" ");
 
348
                pct.write(mFile);
 
349
                fprintf(mFile,";\n");
 
350
        }
 
351
        void setPixelCenterX(float pcx)
 
352
        {
 
353
                if(pcx == 0.0) return;
 
354
                fprintf(mFile,"\tsetAttr \".pct.pcx\" %f;\n", pcx);
 
355
        }
 
356
        void setPixelCenterY(float pcy)
 
357
        {
 
358
                if(pcy == 0.0) return;
 
359
                fprintf(mFile,"\tsetAttr \".pct.pcy\" %f;\n", pcy);
 
360
        }
 
361
        void setHdrMapping(unsigned int hm)
 
362
        {
 
363
                if(hm == 1) return;
 
364
                fprintf(mFile,"\tsetAttr \".hm\" %i;\n", hm);
 
365
        }
 
366
        void setHdrExposure(float he)
 
367
        {
 
368
                if(he == 0.0) return;
 
369
                fprintf(mFile,"\tsetAttr \".he\" %f;\n", he);
 
370
        }
 
371
        void setPreFilter(bool pf)
 
372
        {
 
373
                if(pf == false) return;
 
374
                fprintf(mFile,"\tsetAttr \".pf\" %i;\n", pf);
 
375
        }
 
376
        void setPreFilterRadius(float pfr)
 
377
        {
 
378
                if(pfr == 2.0f) return;
 
379
                fprintf(mFile,"\tsetAttr \".pfr\" %f;\n", pfr);
 
380
        }
 
381
        void getFileTextureName()const
 
382
        {
 
383
                fprintf(mFile,"\"%s.ftn\"",mName.c_str());
 
384
        }
 
385
        void getDisableFileLoad()const
 
386
        {
 
387
                fprintf(mFile,"\"%s.dfl\"",mName.c_str());
 
388
        }
 
389
        void getUseFrameExtension()const
 
390
        {
 
391
                fprintf(mFile,"\"%s.ufe\"",mName.c_str());
 
392
        }
 
393
        void getFrameExtension()const
 
394
        {
 
395
                fprintf(mFile,"\"%s.fe\"",mName.c_str());
 
396
        }
 
397
        void getFrameOffset()const
 
398
        {
 
399
                fprintf(mFile,"\"%s.io\"",mName.c_str());
 
400
        }
 
401
        void getUseHardwareTextureCycling()const
 
402
        {
 
403
                fprintf(mFile,"\"%s.uhc\"",mName.c_str());
 
404
        }
 
405
        void getStartCycleExtension()const
 
406
        {
 
407
                fprintf(mFile,"\"%s.sce\"",mName.c_str());
 
408
        }
 
409
        void getEndCycleExtension()const
 
410
        {
 
411
                fprintf(mFile,"\"%s.ece\"",mName.c_str());
 
412
        }
 
413
        void getByCycleIncrement()const
 
414
        {
 
415
                fprintf(mFile,"\"%s.bci\"",mName.c_str());
 
416
        }
 
417
        void getForceSwatchGen()const
 
418
        {
 
419
                fprintf(mFile,"\"%s.fsg\"",mName.c_str());
 
420
        }
 
421
        void getCoverage()const
 
422
        {
 
423
                fprintf(mFile,"\"%s.c\"",mName.c_str());
 
424
        }
 
425
        void getCoverageU()const
 
426
        {
 
427
                fprintf(mFile,"\"%s.c.cu\"",mName.c_str());
 
428
        }
 
429
        void getCoverageV()const
 
430
        {
 
431
                fprintf(mFile,"\"%s.c.cv\"",mName.c_str());
 
432
        }
 
433
        void getTranslateFrame()const
 
434
        {
 
435
                fprintf(mFile,"\"%s.tf\"",mName.c_str());
 
436
        }
 
437
        void getTranslateFrameU()const
 
438
        {
 
439
                fprintf(mFile,"\"%s.tf.tfu\"",mName.c_str());
 
440
        }
 
441
        void getTranslateFrameV()const
 
442
        {
 
443
                fprintf(mFile,"\"%s.tf.tfv\"",mName.c_str());
 
444
        }
 
445
        void getRotateFrame()const
 
446
        {
 
447
                fprintf(mFile,"\"%s.rf\"",mName.c_str());
 
448
        }
 
449
        void getDoTransform()const
 
450
        {
 
451
                fprintf(mFile,"\"%s.dtf\"",mName.c_str());
 
452
        }
 
453
        void getMirrorU()const
 
454
        {
 
455
                fprintf(mFile,"\"%s.mu\"",mName.c_str());
 
456
        }
 
457
        void getMirrorV()const
 
458
        {
 
459
                fprintf(mFile,"\"%s.mv\"",mName.c_str());
 
460
        }
 
461
        void getStagger()const
 
462
        {
 
463
                fprintf(mFile,"\"%s.s\"",mName.c_str());
 
464
        }
 
465
        void getWrapU()const
 
466
        {
 
467
                fprintf(mFile,"\"%s.wu\"",mName.c_str());
 
468
        }
 
469
        void getWrapV()const
 
470
        {
 
471
                fprintf(mFile,"\"%s.wv\"",mName.c_str());
 
472
        }
 
473
        void getRepeatUV()const
 
474
        {
 
475
                fprintf(mFile,"\"%s.re\"",mName.c_str());
 
476
        }
 
477
        void getRepeatU()const
 
478
        {
 
479
                fprintf(mFile,"\"%s.re.reu\"",mName.c_str());
 
480
        }
 
481
        void getRepeatV()const
 
482
        {
 
483
                fprintf(mFile,"\"%s.re.rev\"",mName.c_str());
 
484
        }
 
485
        void getOffset()const
 
486
        {
 
487
                fprintf(mFile,"\"%s.of\"",mName.c_str());
 
488
        }
 
489
        void getOffsetU()const
 
490
        {
 
491
                fprintf(mFile,"\"%s.of.ofu\"",mName.c_str());
 
492
        }
 
493
        void getOffsetV()const
 
494
        {
 
495
                fprintf(mFile,"\"%s.of.ofv\"",mName.c_str());
 
496
        }
 
497
        void getRotateUV()const
 
498
        {
 
499
                fprintf(mFile,"\"%s.ro\"",mName.c_str());
 
500
        }
 
501
        void getNoiseUV()const
 
502
        {
 
503
                fprintf(mFile,"\"%s.n\"",mName.c_str());
 
504
        }
 
505
        void getNoiseU()const
 
506
        {
 
507
                fprintf(mFile,"\"%s.n.nu\"",mName.c_str());
 
508
        }
 
509
        void getNoiseV()const
 
510
        {
 
511
                fprintf(mFile,"\"%s.n.nv\"",mName.c_str());
 
512
        }
 
513
        void getBlurPixelation()const
 
514
        {
 
515
                fprintf(mFile,"\"%s.blp\"",mName.c_str());
 
516
        }
 
517
        void getVertexCameraOne()const
 
518
        {
 
519
                fprintf(mFile,"\"%s.vc1\"",mName.c_str());
 
520
        }
 
521
        void getVertexCameraOneX()const
 
522
        {
 
523
                fprintf(mFile,"\"%s.vc1.c1x\"",mName.c_str());
 
524
        }
 
525
        void getVertexCameraOneY()const
 
526
        {
 
527
                fprintf(mFile,"\"%s.vc1.c1y\"",mName.c_str());
 
528
        }
 
529
        void getVertexCameraOneZ()const
 
530
        {
 
531
                fprintf(mFile,"\"%s.vc1.c1z\"",mName.c_str());
 
532
        }
 
533
        void getVertexCameraTwo()const
 
534
        {
 
535
                fprintf(mFile,"\"%s.vc2\"",mName.c_str());
 
536
        }
 
537
        void getVertexCameraTwoX()const
 
538
        {
 
539
                fprintf(mFile,"\"%s.vc2.c2x\"",mName.c_str());
 
540
        }
 
541
        void getVertexCameraTwoY()const
 
542
        {
 
543
                fprintf(mFile,"\"%s.vc2.c2y\"",mName.c_str());
 
544
        }
 
545
        void getVertexCameraTwoZ()const
 
546
        {
 
547
                fprintf(mFile,"\"%s.vc2.c2z\"",mName.c_str());
 
548
        }
 
549
        void getVertexCameraThree()const
 
550
        {
 
551
                fprintf(mFile,"\"%s.vc3\"",mName.c_str());
 
552
        }
 
553
        void getVertexCameraThreeX()const
 
554
        {
 
555
                fprintf(mFile,"\"%s.vc3.c3x\"",mName.c_str());
 
556
        }
 
557
        void getVertexCameraThreeY()const
 
558
        {
 
559
                fprintf(mFile,"\"%s.vc3.c3y\"",mName.c_str());
 
560
        }
 
561
        void getVertexCameraThreeZ()const
 
562
        {
 
563
                fprintf(mFile,"\"%s.vc3.c3z\"",mName.c_str());
 
564
        }
 
565
        void getVertexUvOne()const
 
566
        {
 
567
                fprintf(mFile,"\"%s.vt1\"",mName.c_str());
 
568
        }
 
569
        void getVertexUvOneU()const
 
570
        {
 
571
                fprintf(mFile,"\"%s.vt1.t1u\"",mName.c_str());
 
572
        }
 
573
        void getVertexUvOneV()const
 
574
        {
 
575
                fprintf(mFile,"\"%s.vt1.t1v\"",mName.c_str());
 
576
        }
 
577
        void getVertexUvTwo()const
 
578
        {
 
579
                fprintf(mFile,"\"%s.vt2\"",mName.c_str());
 
580
        }
 
581
        void getVertexUvTwoU()const
 
582
        {
 
583
                fprintf(mFile,"\"%s.vt2.t2u\"",mName.c_str());
 
584
        }
 
585
        void getVertexUvTwoV()const
 
586
        {
 
587
                fprintf(mFile,"\"%s.vt2.t2v\"",mName.c_str());
 
588
        }
 
589
        void getVertexUvThree()const
 
590
        {
 
591
                fprintf(mFile,"\"%s.vt3\"",mName.c_str());
 
592
        }
 
593
        void getVertexUvThreeU()const
 
594
        {
 
595
                fprintf(mFile,"\"%s.vt3.t3u\"",mName.c_str());
 
596
        }
 
597
        void getVertexUvThreeV()const
 
598
        {
 
599
                fprintf(mFile,"\"%s.vt3.t3v\"",mName.c_str());
 
600
        }
 
601
        void getObjectType()const
 
602
        {
 
603
                fprintf(mFile,"\"%s.otp\"",mName.c_str());
 
604
        }
 
605
        void getRayDepth()const
 
606
        {
 
607
                fprintf(mFile,"\"%s.rdp\"",mName.c_str());
 
608
        }
 
609
        void getPrimitiveId()const
 
610
        {
 
611
                fprintf(mFile,"\"%s.pi\"",mName.c_str());
 
612
        }
 
613
        void getPixelCenter()const
 
614
        {
 
615
                fprintf(mFile,"\"%s.pct\"",mName.c_str());
 
616
        }
 
617
        void getPixelCenterX()const
 
618
        {
 
619
                fprintf(mFile,"\"%s.pct.pcx\"",mName.c_str());
 
620
        }
 
621
        void getPixelCenterY()const
 
622
        {
 
623
                fprintf(mFile,"\"%s.pct.pcy\"",mName.c_str());
 
624
        }
 
625
        void getOutSize()const
 
626
        {
 
627
                fprintf(mFile,"\"%s.os\"",mName.c_str());
 
628
        }
 
629
        void getOutSizeX()const
 
630
        {
 
631
                fprintf(mFile,"\"%s.os.osx\"",mName.c_str());
 
632
        }
 
633
        void getOutSizeY()const
 
634
        {
 
635
                fprintf(mFile,"\"%s.os.osy\"",mName.c_str());
 
636
        }
 
637
        void getFileHasAlpha()const
 
638
        {
 
639
                fprintf(mFile,"\"%s.fha\"",mName.c_str());
 
640
        }
 
641
        void getOutTransparency()const
 
642
        {
 
643
                fprintf(mFile,"\"%s.ot\"",mName.c_str());
 
644
        }
 
645
        void getOutTransparencyR()const
 
646
        {
 
647
                fprintf(mFile,"\"%s.ot.otr\"",mName.c_str());
 
648
        }
 
649
        void getOutTransparencyG()const
 
650
        {
 
651
                fprintf(mFile,"\"%s.ot.otg\"",mName.c_str());
 
652
        }
 
653
        void getOutTransparencyB()const
 
654
        {
 
655
                fprintf(mFile,"\"%s.ot.otb\"",mName.c_str());
 
656
        }
 
657
        void getPreFilter()const
 
658
        {
 
659
                fprintf(mFile,"\"%s.pf\"",mName.c_str());
 
660
        }
 
661
        void getPreFilterRadius()const
 
662
        {
 
663
                fprintf(mFile,"\"%s.pfr\"",mName.c_str());
 
664
        }
 
665
        void getInfoBits()const
 
666
        {
 
667
                fprintf(mFile,"\"%s.ib\"",mName.c_str());
 
668
        }
 
669
protected:
 
670
        File(FILE* file,const std::string& name,const std::string& parent,const std::string& nodeType,bool shared=false,bool create=true)
 
671
                :Texture2d(file, name, parent, nodeType, shared, create) {}
 
672
 
 
673
};
 
674
}//namespace MayaDM
 
675
#endif//__MayaDM_FILE_H__