← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Externals/MayaDataModel/include/MayaDMLightLinker.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/MayaDMLightLinker.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_LIGHTLINKER_H__
 
11
#define __MayaDM_LIGHTLINKER_H__
 
12
#include "MayaDMTypes.h"
 
13
#include "MayaDMConnectables.h"
 
14
#include "MayaDMDependNode.h"
 
15
namespace MayaDM
 
16
{
 
17
class LightLinker : public DependNode
 
18
{
 
19
public:
 
20
        struct Link{
 
21
                void write(FILE* file) const
 
22
                {
 
23
                }
 
24
        };
 
25
        struct Ignore{
 
26
                void write(FILE* file) const
 
27
                {
 
28
                }
 
29
        };
 
30
        struct ShadowLink{
 
31
                void write(FILE* file) const
 
32
                {
 
33
                }
 
34
        };
 
35
        struct ShadowIgnore{
 
36
                void write(FILE* file) const
 
37
                {
 
38
                }
 
39
        };
 
40
public:
 
41
 
 
42
        LightLinker():DependNode(){}
 
43
        LightLinker(FILE* file,const std::string& name,const std::string& parent="",bool shared=false,bool create=true)
 
44
                :DependNode(file, name, parent, "lightLinker", shared, create){}
 
45
        virtual ~LightLinker(){}
 
46
 
 
47
        void setLink(size_t lnk_i,const Link& lnk)
 
48
        {
 
49
                fprintf(mFile,"\tsetAttr \".lnk[%i]\" ",lnk_i);
 
50
                lnk.write(mFile);
 
51
                fprintf(mFile,";\n");
 
52
        }
 
53
        void setLink(size_t lnk_start,size_t lnk_end,Link* lnk)
 
54
        {
 
55
                fprintf(mFile,"\tsetAttr \".lnk[%i:%i]\" ", lnk_start,lnk_end);
 
56
                size_t size = (lnk_end-lnk_start)*1+1;
 
57
                for(size_t i=0;i<size;++i)
 
58
                {
 
59
                        lnk[i].write(mFile);
 
60
                        fprintf(mFile,"\n");
 
61
                }
 
62
                fprintf(mFile,";\n");
 
63
        }
 
64
        void startLink(size_t lnk_start,size_t lnk_end)const
 
65
        {
 
66
                fprintf(mFile,"\tsetAttr \".lnk[%i:%i]\"",lnk_start,lnk_end);
 
67
                fprintf(mFile," -type \"Link\" ");
 
68
        }
 
69
        void appendLink(const Link& lnk)const
 
70
        {
 
71
                fprintf(mFile," ");
 
72
                lnk.write(mFile);
 
73
        }
 
74
        void endLink()const
 
75
        {
 
76
                fprintf(mFile,";\n");
 
77
        }
 
78
        void setIgnore(size_t ign_i,const Ignore& ign)
 
79
        {
 
80
                fprintf(mFile,"\tsetAttr \".ign[%i]\" ",ign_i);
 
81
                ign.write(mFile);
 
82
                fprintf(mFile,";\n");
 
83
        }
 
84
        void setIgnore(size_t ign_start,size_t ign_end,Ignore* ign)
 
85
        {
 
86
                fprintf(mFile,"\tsetAttr \".ign[%i:%i]\" ", ign_start,ign_end);
 
87
                size_t size = (ign_end-ign_start)*1+1;
 
88
                for(size_t i=0;i<size;++i)
 
89
                {
 
90
                        ign[i].write(mFile);
 
91
                        fprintf(mFile,"\n");
 
92
                }
 
93
                fprintf(mFile,";\n");
 
94
        }
 
95
        void startIgnore(size_t ign_start,size_t ign_end)const
 
96
        {
 
97
                fprintf(mFile,"\tsetAttr \".ign[%i:%i]\"",ign_start,ign_end);
 
98
                fprintf(mFile," -type \"Ignore\" ");
 
99
        }
 
100
        void appendIgnore(const Ignore& ign)const
 
101
        {
 
102
                fprintf(mFile," ");
 
103
                ign.write(mFile);
 
104
        }
 
105
        void endIgnore()const
 
106
        {
 
107
                fprintf(mFile,";\n");
 
108
        }
 
109
        void setShadowLink(size_t slnk_i,const ShadowLink& slnk)
 
110
        {
 
111
                fprintf(mFile,"\tsetAttr \".slnk[%i]\" ",slnk_i);
 
112
                slnk.write(mFile);
 
113
                fprintf(mFile,";\n");
 
114
        }
 
115
        void setShadowLink(size_t slnk_start,size_t slnk_end,ShadowLink* slnk)
 
116
        {
 
117
                fprintf(mFile,"\tsetAttr \".slnk[%i:%i]\" ", slnk_start,slnk_end);
 
118
                size_t size = (slnk_end-slnk_start)*1+1;
 
119
                for(size_t i=0;i<size;++i)
 
120
                {
 
121
                        slnk[i].write(mFile);
 
122
                        fprintf(mFile,"\n");
 
123
                }
 
124
                fprintf(mFile,";\n");
 
125
        }
 
126
        void startShadowLink(size_t slnk_start,size_t slnk_end)const
 
127
        {
 
128
                fprintf(mFile,"\tsetAttr \".slnk[%i:%i]\"",slnk_start,slnk_end);
 
129
                fprintf(mFile," -type \"ShadowLink\" ");
 
130
        }
 
131
        void appendShadowLink(const ShadowLink& slnk)const
 
132
        {
 
133
                fprintf(mFile," ");
 
134
                slnk.write(mFile);
 
135
        }
 
136
        void endShadowLink()const
 
137
        {
 
138
                fprintf(mFile,";\n");
 
139
        }
 
140
        void setShadowIgnore(size_t sign_i,const ShadowIgnore& sign)
 
141
        {
 
142
                fprintf(mFile,"\tsetAttr \".sign[%i]\" ",sign_i);
 
143
                sign.write(mFile);
 
144
                fprintf(mFile,";\n");
 
145
        }
 
146
        void setShadowIgnore(size_t sign_start,size_t sign_end,ShadowIgnore* sign)
 
147
        {
 
148
                fprintf(mFile,"\tsetAttr \".sign[%i:%i]\" ", sign_start,sign_end);
 
149
                size_t size = (sign_end-sign_start)*1+1;
 
150
                for(size_t i=0;i<size;++i)
 
151
                {
 
152
                        sign[i].write(mFile);
 
153
                        fprintf(mFile,"\n");
 
154
                }
 
155
                fprintf(mFile,";\n");
 
156
        }
 
157
        void startShadowIgnore(size_t sign_start,size_t sign_end)const
 
158
        {
 
159
                fprintf(mFile,"\tsetAttr \".sign[%i:%i]\"",sign_start,sign_end);
 
160
                fprintf(mFile," -type \"ShadowIgnore\" ");
 
161
        }
 
162
        void appendShadowIgnore(const ShadowIgnore& sign)const
 
163
        {
 
164
                fprintf(mFile," ");
 
165
                sign.write(mFile);
 
166
        }
 
167
        void endShadowIgnore()const
 
168
        {
 
169
                fprintf(mFile,";\n");
 
170
        }
 
171
        void getLink(size_t lnk_i)const
 
172
        {
 
173
                fprintf(mFile,"\"%s.lnk[%i]\"",mName.c_str(),lnk_i);
 
174
        }
 
175
        void getLink()const
 
176
        {
 
177
 
 
178
                fprintf(mFile,"\"%s.lnk\"",mName.c_str());
 
179
        }
 
180
        void getLight(size_t lnk_i)const
 
181
        {
 
182
                fprintf(mFile,"\"%s.lnk[%i].llnk\"",mName.c_str(),lnk_i);
 
183
        }
 
184
        void getLight()const
 
185
        {
 
186
 
 
187
                fprintf(mFile,"\"%s.lnk.llnk\"",mName.c_str());
 
188
        }
 
189
        void getObject(size_t lnk_i)const
 
190
        {
 
191
                fprintf(mFile,"\"%s.lnk[%i].olnk\"",mName.c_str(),lnk_i);
 
192
        }
 
193
        void getObject()const
 
194
        {
 
195
 
 
196
                fprintf(mFile,"\"%s.lnk.olnk\"",mName.c_str());
 
197
        }
 
198
        void getIgnore(size_t ign_i)const
 
199
        {
 
200
                fprintf(mFile,"\"%s.ign[%i]\"",mName.c_str(),ign_i);
 
201
        }
 
202
        void getIgnore()const
 
203
        {
 
204
 
 
205
                fprintf(mFile,"\"%s.ign\"",mName.c_str());
 
206
        }
 
207
        void getLightIgnored(size_t ign_i)const
 
208
        {
 
209
                fprintf(mFile,"\"%s.ign[%i].lign\"",mName.c_str(),ign_i);
 
210
        }
 
211
        void getLightIgnored()const
 
212
        {
 
213
 
 
214
                fprintf(mFile,"\"%s.ign.lign\"",mName.c_str());
 
215
        }
 
216
        void getObjectIgnored(size_t ign_i)const
 
217
        {
 
218
                fprintf(mFile,"\"%s.ign[%i].oign\"",mName.c_str(),ign_i);
 
219
        }
 
220
        void getObjectIgnored()const
 
221
        {
 
222
 
 
223
                fprintf(mFile,"\"%s.ign.oign\"",mName.c_str());
 
224
        }
 
225
        void getShadowLink(size_t slnk_i)const
 
226
        {
 
227
                fprintf(mFile,"\"%s.slnk[%i]\"",mName.c_str(),slnk_i);
 
228
        }
 
229
        void getShadowLink()const
 
230
        {
 
231
 
 
232
                fprintf(mFile,"\"%s.slnk\"",mName.c_str());
 
233
        }
 
234
        void getShadowLight(size_t slnk_i)const
 
235
        {
 
236
                fprintf(mFile,"\"%s.slnk[%i].sllk\"",mName.c_str(),slnk_i);
 
237
        }
 
238
        void getShadowLight()const
 
239
        {
 
240
 
 
241
                fprintf(mFile,"\"%s.slnk.sllk\"",mName.c_str());
 
242
        }
 
243
        void getShadowObject(size_t slnk_i)const
 
244
        {
 
245
                fprintf(mFile,"\"%s.slnk[%i].solk\"",mName.c_str(),slnk_i);
 
246
        }
 
247
        void getShadowObject()const
 
248
        {
 
249
 
 
250
                fprintf(mFile,"\"%s.slnk.solk\"",mName.c_str());
 
251
        }
 
252
        void getShadowIgnore(size_t sign_i)const
 
253
        {
 
254
                fprintf(mFile,"\"%s.sign[%i]\"",mName.c_str(),sign_i);
 
255
        }
 
256
        void getShadowIgnore()const
 
257
        {
 
258
 
 
259
                fprintf(mFile,"\"%s.sign\"",mName.c_str());
 
260
        }
 
261
        void getShadowLightIgnored(size_t sign_i)const
 
262
        {
 
263
                fprintf(mFile,"\"%s.sign[%i].slig\"",mName.c_str(),sign_i);
 
264
        }
 
265
        void getShadowLightIgnored()const
 
266
        {
 
267
 
 
268
                fprintf(mFile,"\"%s.sign.slig\"",mName.c_str());
 
269
        }
 
270
        void getShadowObjectIgnored(size_t sign_i)const
 
271
        {
 
272
                fprintf(mFile,"\"%s.sign[%i].soig\"",mName.c_str(),sign_i);
 
273
        }
 
274
        void getShadowObjectIgnored()const
 
275
        {
 
276
 
 
277
                fprintf(mFile,"\"%s.sign.soig\"",mName.c_str());
 
278
        }
 
279
protected:
 
280
        LightLinker(FILE* file,const std::string& name,const std::string& parent,const std::string& nodeType,bool shared=false,bool create=true)
 
281
                :DependNode(file, name, parent, nodeType, shared, create) {}
 
282
 
 
283
};
 
284
}//namespace MayaDM
 
285
#endif//__MayaDM_LIGHTLINKER_H__