← Back to branch summary

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

« back to all changes in this revision

Viewing changes to COLLADASaxFrameworkLoader/src/generated14/COLLADASaxFWLLibraryControllersLoader14.cpp

  • 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:
COLLADASaxFrameworkLoader/src/generated14/COLLADASaxFWLLibraryControllersLoader14.cpp
 
1
/*
 
2
    Copyright (c) 2008-2009 NetAllied Systems GmbH
 
3
 
 
4
    This file is part of COLLADASaxFrameworkLoader.
 
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
 
 
11
 
 
12
#include "COLLADASaxFWLStableHeaders.h"
 
13
#include "COLLADASaxFWLLibraryControllersLoader14.h"
 
14
 
 
15
 
 
16
namespace COLLADASaxFWL
 
17
{
 
18
 
 
19
 
 
20
bool LibraryControllersLoader14::end__library_controllers()
 
21
{
 
22
SaxVirtualFunctionTest14(end__library_controllers());
 
23
return mLoader->end__library_controllers();
 
24
}
 
25
 
 
26
 
 
27
bool LibraryControllersLoader14::begin__controller( const COLLADASaxFWL14::controller__AttributeData& attributeData )
 
28
{
 
29
SaxVirtualFunctionTest14(begin__controller(attributeData));
 
30
COLLADASaxFWL::controller__AttributeData attrData;
 
31
attrData.id = attributeData.id;
 
32
attrData.name = attributeData.name;
 
33
return mLoader->begin__controller(attrData);
 
34
}
 
35
 
 
36
 
 
37
bool LibraryControllersLoader14::end__controller()
 
38
{
 
39
SaxVirtualFunctionTest14(end__controller());
 
40
return mLoader->end__controller();
 
41
}
 
42
 
 
43
 
 
44
bool LibraryControllersLoader14::begin__skin( const COLLADASaxFWL14::skin__AttributeData& attributeData )
 
45
{
 
46
SaxVirtualFunctionTest14(begin__skin(attributeData));
 
47
COLLADASaxFWL::skin__AttributeData attrData;
 
48
attrData.present_attributes = 0;
 
49
if ( (attributeData.present_attributes & COLLADASaxFWL14::skin__AttributeData::ATTRIBUTE_SOURCE_PRESENT) == COLLADASaxFWL14::skin__AttributeData::ATTRIBUTE_SOURCE_PRESENT ) {
 
50
    attrData.source = attributeData.source;
 
51
    attrData.present_attributes |= COLLADASaxFWL::skin__AttributeData::ATTRIBUTE_SOURCE_PRESENT;
 
52
}
 
53
return mLoader->begin__skin(attrData);
 
54
}
 
55
 
 
56
 
 
57
bool LibraryControllersLoader14::end__skin()
 
58
{
 
59
SaxVirtualFunctionTest14(end__skin());
 
60
return mLoader->end__skin();
 
61
}
 
62
 
 
63
 
 
64
bool LibraryControllersLoader14::begin__morph( const COLLADASaxFWL14::morph__AttributeData& attributeData )
 
65
{
 
66
SaxVirtualFunctionTest14(begin__morph(attributeData));
 
67
COLLADASaxFWL::morph__AttributeData attrData;
 
68
attrData.present_attributes = 0;
 
69
if ( (attributeData.present_attributes & COLLADASaxFWL14::morph__AttributeData::ATTRIBUTE_SOURCE_PRESENT) == COLLADASaxFWL14::morph__AttributeData::ATTRIBUTE_SOURCE_PRESENT ) {
 
70
    attrData.source = attributeData.source;
 
71
    attrData.present_attributes |= COLLADASaxFWL::morph__AttributeData::ATTRIBUTE_SOURCE_PRESENT;
 
72
}
 
73
switch (attributeData.method) {
 
74
case COLLADASaxFWL14::ENUM__MorphMethodType__NORMALIZED: attrData.method=COLLADASaxFWL::ENUM__MorphMethodType__NORMALIZED; break;
 
75
case COLLADASaxFWL14::ENUM__MorphMethodType__RELATIVE: attrData.method=COLLADASaxFWL::ENUM__MorphMethodType__RELATIVE; break;
 
76
case COLLADASaxFWL14::ENUM__MorphMethodType__COUNT: attrData.method=COLLADASaxFWL::ENUM__MorphMethodType__INVLAID; break;
 
77
case COLLADASaxFWL14::ENUM__MorphMethodType__NOT_PRESENT: attrData.method=COLLADASaxFWL::ENUM__MorphMethodType__NOT_PRESENT; break;
 
78
}
 
79
return mLoader->begin__morph(attrData);
 
80
}
 
81
 
 
82
 
 
83
bool LibraryControllersLoader14::end__morph()
 
84
{
 
85
SaxVirtualFunctionTest14(end__morph());
 
86
return mLoader->end__morph();
 
87
}
 
88
 
 
89
 
 
90
bool LibraryControllersLoader14::begin__source( const COLLADASaxFWL14::source__AttributeData& attributeData )
 
91
{
 
92
SaxVirtualFunctionTest14(begin__source(attributeData));
 
93
COLLADASaxFWL::source__AttributeData attrData;
 
94
attrData.id = attributeData.id;
 
95
attrData.name = attributeData.name;
 
96
return mLoader->begin__source(attrData);
 
97
}
 
98
 
 
99
 
 
100
bool LibraryControllersLoader14::end__source()
 
101
{
 
102
SaxVirtualFunctionTest14(end__source());
 
103
return mLoader->end__source();
 
104
}
 
105
 
 
106
 
 
107
bool LibraryControllersLoader14::begin__joints()
 
108
{
 
109
SaxVirtualFunctionTest14(begin__joints());
 
110
return mLoader->begin__joints();
 
111
}
 
112
 
 
113
 
 
114
bool LibraryControllersLoader14::end__joints()
 
115
{
 
116
SaxVirtualFunctionTest14(end__joints());
 
117
return mLoader->end__joints();
 
118
}
 
119
 
 
120
 
 
121
bool LibraryControllersLoader14::begin__input____InputLocal( const COLLADASaxFWL14::input____InputLocal__AttributeData& attributeData )
 
122
{
 
123
SaxVirtualFunctionTest14(begin__input____InputLocal(attributeData));
 
124
COLLADASaxFWL::input____InputLocal__AttributeData attrData;
 
125
attrData.semantic = attributeData.semantic;
 
126
attrData.source = attributeData.source;
 
127
return mLoader->begin__input____InputLocal(attrData);
 
128
}
 
129
 
 
130
 
 
131
bool LibraryControllersLoader14::end__input____InputLocal()
 
132
{
 
133
SaxVirtualFunctionTest14(end__input____InputLocal());
 
134
return mLoader->end__input____InputLocal();
 
135
}
 
136
 
 
137
 
 
138
bool LibraryControllersLoader14::begin__input____InputLocalOffset( const COLLADASaxFWL14::input____InputLocalOffset__AttributeData& attributeData )
 
139
{
 
140
SaxVirtualFunctionTest14(begin__input____InputLocalOffset(attributeData));
 
141
COLLADASaxFWL::input____InputLocalOffset__AttributeData attrData;
 
142
attrData.present_attributes = 0;
 
143
attrData.semantic = attributeData.semantic;
 
144
attrData.source = attributeData.source;
 
145
if ( (attributeData.present_attributes & COLLADASaxFWL14::input____InputLocalOffset__AttributeData::ATTRIBUTE_OFFSET_PRESENT) == COLLADASaxFWL14::input____InputLocalOffset__AttributeData::ATTRIBUTE_OFFSET_PRESENT ) {
 
146
    attrData.offset = attributeData.offset;
 
147
    attrData.present_attributes |= COLLADASaxFWL::input____InputLocalOffset__AttributeData::ATTRIBUTE_OFFSET_PRESENT;
 
148
}
 
149
if ( (attributeData.present_attributes & COLLADASaxFWL14::input____InputLocalOffset__AttributeData::ATTRIBUTE_SET_PRESENT) == COLLADASaxFWL14::input____InputLocalOffset__AttributeData::ATTRIBUTE_SET_PRESENT ) {
 
150
    attrData.set = attributeData.set;
 
151
    attrData.present_attributes |= COLLADASaxFWL::input____InputLocalOffset__AttributeData::ATTRIBUTE_SET_PRESENT;
 
152
}
 
153
return mLoader->begin__input____InputLocalOffset(attrData);
 
154
}
 
155
 
 
156
 
 
157
bool LibraryControllersLoader14::end__input____InputLocalOffset()
 
158
{
 
159
SaxVirtualFunctionTest14(end__input____InputLocalOffset());
 
160
return mLoader->end__input____InputLocalOffset();
 
161
}
 
162
 
 
163
 
 
164
bool LibraryControllersLoader14::begin__vertex_weights( const COLLADASaxFWL14::vertex_weights__AttributeData& attributeData )
 
165
{
 
166
SaxVirtualFunctionTest14(begin__vertex_weights(attributeData));
 
167
COLLADASaxFWL::vertex_weights__AttributeData attrData;
 
168
attrData.present_attributes = 0;
 
169
if ( (attributeData.present_attributes & COLLADASaxFWL14::vertex_weights__AttributeData::ATTRIBUTE_COUNT_PRESENT) == COLLADASaxFWL14::vertex_weights__AttributeData::ATTRIBUTE_COUNT_PRESENT ) {
 
170
    attrData.count = attributeData.count;
 
171
    attrData.present_attributes |= COLLADASaxFWL::vertex_weights__AttributeData::ATTRIBUTE_COUNT_PRESENT;
 
172
}
 
173
return mLoader->begin__vertex_weights(attrData);
 
174
}
 
175
 
 
176
 
 
177
bool LibraryControllersLoader14::end__vertex_weights()
 
178
{
 
179
SaxVirtualFunctionTest14(end__vertex_weights());
 
180
return mLoader->end__vertex_weights();
 
181
}
 
182
 
 
183
 
 
184
bool LibraryControllersLoader14::begin__vcount()
 
185
{
 
186
SaxVirtualFunctionTest14(begin__vcount());
 
187
return mLoader->begin__vcount();
 
188
}
 
189
 
 
190
 
 
191
bool LibraryControllersLoader14::end__vcount()
 
192
{
 
193
SaxVirtualFunctionTest14(end__vcount());
 
194
return mLoader->end__vcount();
 
195
}
 
196
 
 
197
 
 
198
bool LibraryControllersLoader14::data__vcount( const uint64* data, size_t length )
 
199
{
 
200
SaxVirtualFunctionTest14(data__vcount(data, length));
 
201
return mLoader->data__vcount(data, length);
 
202
}
 
203
 
 
204
 
 
205
bool LibraryControllersLoader14::begin__v()
 
206
{
 
207
SaxVirtualFunctionTest14(begin__v());
 
208
return mLoader->begin__v();
 
209
}
 
210
 
 
211
 
 
212
bool LibraryControllersLoader14::end__v()
 
213
{
 
214
SaxVirtualFunctionTest14(end__v());
 
215
return mLoader->end__v();
 
216
}
 
217
 
 
218
 
 
219
bool LibraryControllersLoader14::data__v( const sint64* data, size_t length )
 
220
{
 
221
SaxVirtualFunctionTest14(data__v(data, length));
 
222
return mLoader->data__v(data, length);
 
223
}
 
224
 
 
225
 
 
226
bool LibraryControllersLoader14::begin__Name_array( const COLLADASaxFWL14::Name_array__AttributeData& attributeData )
 
227
{
 
228
SaxVirtualFunctionTest14(begin__Name_array(attributeData));
 
229
COLLADASaxFWL::Name_array__AttributeData attrData;
 
230
attrData.present_attributes = 0;
 
231
attrData.id = attributeData.id;
 
232
attrData.name = attributeData.name;
 
233
if ( (attributeData.present_attributes & COLLADASaxFWL14::Name_array__AttributeData::ATTRIBUTE_COUNT_PRESENT) == COLLADASaxFWL14::Name_array__AttributeData::ATTRIBUTE_COUNT_PRESENT ) {
 
234
    attrData.count = attributeData.count;
 
235
    attrData.present_attributes |= COLLADASaxFWL::Name_array__AttributeData::ATTRIBUTE_COUNT_PRESENT;
 
236
}
 
237
return mLoader->begin__Name_array(attrData);
 
238
}
 
239
 
 
240
 
 
241
bool LibraryControllersLoader14::end__Name_array()
 
242
{
 
243
SaxVirtualFunctionTest14(end__Name_array());
 
244
return mLoader->end__Name_array();
 
245
}
 
246
 
 
247
 
 
248
bool LibraryControllersLoader14::data__Name_array( const ParserString* data, size_t length )
 
249
{
 
250
SaxVirtualFunctionTest14(data__Name_array(data, length));
 
251
return mLoader->data__Name_array(data, length);
 
252
}
 
253
 
 
254
 
 
255
bool LibraryControllersLoader14::begin__IDREF_array( const COLLADASaxFWL14::IDREF_array__AttributeData& attributeData )
 
256
{
 
257
SaxVirtualFunctionTest14(begin__IDREF_array(attributeData));
 
258
COLLADASaxFWL::IDREF_array__AttributeData attrData;
 
259
attrData.present_attributes = 0;
 
260
attrData.id = attributeData.id;
 
261
attrData.name = attributeData.name;
 
262
if ( (attributeData.present_attributes & COLLADASaxFWL14::IDREF_array__AttributeData::ATTRIBUTE_COUNT_PRESENT) == COLLADASaxFWL14::IDREF_array__AttributeData::ATTRIBUTE_COUNT_PRESENT ) {
 
263
    attrData.count = attributeData.count;
 
264
    attrData.present_attributes |= COLLADASaxFWL::IDREF_array__AttributeData::ATTRIBUTE_COUNT_PRESENT;
 
265
}
 
266
return mLoader->begin__IDREF_array(attrData);
 
267
}
 
268
 
 
269
 
 
270
bool LibraryControllersLoader14::end__IDREF_array()
 
271
{
 
272
SaxVirtualFunctionTest14(end__IDREF_array());
 
273
return mLoader->end__IDREF_array();
 
274
}
 
275
 
 
276
 
 
277
bool LibraryControllersLoader14::data__IDREF_array( const ParserString* data, size_t length )
 
278
{
 
279
SaxVirtualFunctionTest14(data__IDREF_array(data, length));
 
280
return mLoader->data__IDREF_array(data, length);
 
281
}
 
282
 
 
283
 
 
284
bool LibraryControllersLoader14::begin__bind_shape_matrix()
 
285
{
 
286
SaxVirtualFunctionTest14(begin__bind_shape_matrix());
 
287
return mLoader->begin__bind_shape_matrix();
 
288
}
 
289
 
 
290
 
 
291
bool LibraryControllersLoader14::end__bind_shape_matrix()
 
292
{
 
293
SaxVirtualFunctionTest14(end__bind_shape_matrix());
 
294
return mLoader->end__bind_shape_matrix();
 
295
}
 
296
 
 
297
 
 
298
bool LibraryControllersLoader14::data__bind_shape_matrix( const float* data, size_t length )
 
299
{
 
300
SaxVirtualFunctionTest14(data__bind_shape_matrix(data, length));
 
301
return mLoader->data__bind_shape_matrix(data, length);
 
302
}
 
303
 
 
304
 
 
305
bool LibraryControllersLoader14::begin__technique( const COLLADASaxFWL14::technique__AttributeData& attributeData )
 
306
{
 
307
SaxVirtualFunctionTest14(begin__technique(attributeData));
 
308
COLLADASaxFWL::technique__AttributeData attrData;
 
309
attrData.profile = attributeData.profile;
 
310
return mLoader->begin__technique(attrData);
 
311
}
 
312
 
 
313
 
 
314
bool LibraryControllersLoader14::end__technique()
 
315
{
 
316
SaxVirtualFunctionTest14(end__technique());
 
317
return mLoader->end__technique();
 
318
}
 
319
 
 
320
 
 
321
 
 
322
}