← Back to branch summary

~ubuntu-branches/debian/experimental/openscenegraph/experimental

« back to all changes in this revision

Viewing changes to OpenSceneGraph/src/osgWrappers/osgVolume/Layer.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alberto Luaces
  • Date: 2011-01-29 11:36:29 UTC
  • mfrom: (1.1.10 upstream)
  • Revision ID: james.westby@ubuntu.com-20110129113629-qisrm2kdqlurc7t3
Tags: 2.9.11-1
http://bugs.debian.org/592420
* Removed bug-555869-ftbfs_with_binutils_gold.dpatch since upstream has
  already taken care of the issue.
* Removed bug-528229.dpatch since the pkgconfig files are now also split
  in upstream.
* Removed explicit dependency on GLU.
* Upstream no longer includes osgIntrospection (Closes: #592420).
* Disabled zip plugin as its implementation stores an embedded copy of
  zlib.
* Enabled Qt support. Thanks James Goppert.
* Enabled SVG and PDF plugins. Thanks James Goppert.

Show diffs side-by-side

added added

removed removed

Lines of Context:
OpenSceneGraph/src/osgWrappers/osgVolume/Layer.cpp
1
 
// ***************************************************************************
2
 
//
3
 
//   Generated automatically by genwrapper.
4
 
//   Please DO NOT EDIT this file!
5
 
//
6
 
// ***************************************************************************
7
 
 
8
 
#include <osgIntrospection/ReflectionMacros>
9
 
#include <osgIntrospection/TypedMethodInfo>
10
 
#include <osgIntrospection/StaticMethodInfo>
11
 
#include <osgIntrospection/Attributes>
12
 
 
13
 
#include <osg/BoundingSphere>
14
 
#include <osg/CopyOp>
15
 
#include <osg/Image>
16
 
#include <osg/NodeVisitor>
17
 
#include <osg/Object>
18
 
#include <osg/Texture>
19
 
#include <osg/Vec4>
20
 
#include <osgVolume/Layer>
21
 
#include <osgVolume/Locator>
22
 
#include <osgVolume/Property>
23
 
 
24
 
// Must undefine IN and OUT macros defined in Windows headers
25
 
#ifdef IN
26
 
#undef IN
27
 
#endif
28
 
#ifdef OUT
29
 
#undef OUT
30
 
#endif
31
 
 
32
 
BEGIN_OBJECT_REFLECTOR(osgVolume::CompositeLayer)
33
 
        I_DeclaringFile("osgVolume/Layer");
34
 
        I_BaseType(osgVolume::Layer);
35
 
        I_Constructor0(____CompositeLayer,
36
 
                       "",
37
 
                       "");
38
 
        I_ConstructorWithDefaults2(IN, const osgVolume::CompositeLayer &, compositeLayer, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY,
39
 
                                   ____CompositeLayer__C5_CompositeLayer_R1__C5_osg_CopyOp_R1,
40
 
                                   "Copy constructor using CopyOp to manage deep vs shallow copy. ",
41
 
                                   "");
42
 
        I_Method0(osg::Object *, cloneType,
43
 
                  Properties::VIRTUAL,
44
 
                  __osg_Object_P1__cloneType,
45
 
                  "Clone the type of an object, with Object* return type. ",
46
 
                  "Must be defined by derived classes. ");
47
 
        I_Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop,
48
 
                  Properties::VIRTUAL,
49
 
                  __osg_Object_P1__clone__C5_osg_CopyOp_R1,
50
 
                  "Clone an object, with Object* return type. ",
51
 
                  "Must be defined by derived classes. ");
52
 
        I_Method1(bool, isSameKindAs, IN, const osg::Object *, obj,
53
 
                  Properties::VIRTUAL,
54
 
                  __bool__isSameKindAs__C5_osg_Object_P1,
55
 
                  "",
56
 
                  "");
57
 
        I_Method0(const char *, libraryName,
58
 
                  Properties::VIRTUAL,
59
 
                  __C5_char_P1__libraryName,
60
 
                  "return the name of the object's library. ",
61
 
                  "Must be defined by derived classes. The OpenSceneGraph convention is that the namespace of a library is the same as the library name. ");
62
 
        I_Method0(const char *, className,
63
 
                  Properties::VIRTUAL,
64
 
                  __C5_char_P1__className,
65
 
                  "return the name of the object's class type. ",
66
 
                  "Must be defined by derived classes. ");
67
 
        I_Method0(void, clear,
68
 
                  Properties::NON_VIRTUAL,
69
 
                  __void__clear,
70
 
                  "",
71
 
                  "");
72
 
        I_Method2(void, setFileName, IN, unsigned int, i, IN, const std::string &, filename,
73
 
                  Properties::NON_VIRTUAL,
74
 
                  __void__setFileName__unsigned_int__C5_std_string_R1,
75
 
                  "",
76
 
                  "");
77
 
        I_Method1(const std::string &, getFileName, IN, unsigned int, i,
78
 
                  Properties::NON_VIRTUAL,
79
 
                  __C5_std_string_R1__getFileName__unsigned_int,
80
 
                  "",
81
 
                  "");
82
 
        I_Method2(void, setLayer, IN, unsigned int, i, IN, osgVolume::Layer *, layer,
83
 
                  Properties::NON_VIRTUAL,
84
 
                  __void__setLayer__unsigned_int__Layer_P1,
85
 
                  "",
86
 
                  "");
87
 
        I_Method1(osgVolume::Layer *, getLayer, IN, unsigned int, i,
88
 
                  Properties::NON_VIRTUAL,
89
 
                  __Layer_P1__getLayer__unsigned_int,
90
 
                  "",
91
 
                  "");
92
 
        I_Method1(const osgVolume::Layer *, getLayer, IN, unsigned int, i,
93
 
                  Properties::NON_VIRTUAL,
94
 
                  __C5_Layer_P1__getLayer__unsigned_int,
95
 
                  "",
96
 
                  "");
97
 
        I_Method1(void, addLayer, IN, osgVolume::Layer *, layer,
98
 
                  Properties::NON_VIRTUAL,
99
 
                  __void__addLayer__Layer_P1,
100
 
                  "",
101
 
                  "");
102
 
        I_Method1(void, removeLayer, IN, unsigned int, i,
103
 
                  Properties::NON_VIRTUAL,
104
 
                  __void__removeLayer__unsigned_int,
105
 
                  "",
106
 
                  "");
107
 
        I_Method0(unsigned int, getNumLayers,
108
 
                  Properties::NON_VIRTUAL,
109
 
                  __unsigned_int__getNumLayers,
110
 
                  "",
111
 
                  "");
112
 
        I_Method0(bool, requiresUpdateTraversal,
113
 
                  Properties::VIRTUAL,
114
 
                  __bool__requiresUpdateTraversal,
115
 
                  "Specify whether ImageLayer requires update traversal. ",
116
 
                  "");
117
 
        I_Method1(void, update, IN, osg::NodeVisitor &, x,
118
 
                  Properties::VIRTUAL,
119
 
                  __void__update__osg_NodeVisitor_R1,
120
 
                  "Call update on the Layer. ",
121
 
                  "");
122
 
        I_IndexedProperty(const std::string &, FileName, 
123
 
                          __C5_std_string_R1__getFileName__unsigned_int, 
124
 
                          __void__setFileName__unsigned_int__C5_std_string_R1, 
125
 
                          0);
126
 
        I_ArrayProperty(osgVolume::Layer *, Layer, 
127
 
                        __Layer_P1__getLayer__unsigned_int, 
128
 
                        __void__setLayer__unsigned_int__Layer_P1, 
129
 
                        __unsigned_int__getNumLayers, 
130
 
                        __void__addLayer__Layer_P1, 
131
 
                        0, 
132
 
                        __void__removeLayer__unsigned_int);
133
 
END_REFLECTOR
134
 
 
135
 
BEGIN_OBJECT_REFLECTOR(osgVolume::ImageLayer)
136
 
        I_DeclaringFile("osgVolume/Layer");
137
 
        I_BaseType(osgVolume::Layer);
138
 
        I_ConstructorWithDefaults1(IN, osg::Image *, image, 0,
139
 
                                   Properties::NON_EXPLICIT,
140
 
                                   ____ImageLayer__osg_Image_P1,
141
 
                                   "",
142
 
                                   "");
143
 
        I_ConstructorWithDefaults2(IN, const osgVolume::ImageLayer &, imageLayer, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY,
144
 
                                   ____ImageLayer__C5_ImageLayer_R1__C5_osg_CopyOp_R1,
145
 
                                   "Copy constructor using CopyOp to manage deep vs shallow copy. ",
146
 
                                   "");
147
 
        I_Method0(osg::Object *, cloneType,
148
 
                  Properties::VIRTUAL,
149
 
                  __osg_Object_P1__cloneType,
150
 
                  "Clone the type of an object, with Object* return type. ",
151
 
                  "Must be defined by derived classes. ");
152
 
        I_Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop,
153
 
                  Properties::VIRTUAL,
154
 
                  __osg_Object_P1__clone__C5_osg_CopyOp_R1,
155
 
                  "Clone an object, with Object* return type. ",
156
 
                  "Must be defined by derived classes. ");
157
 
        I_Method1(bool, isSameKindAs, IN, const osg::Object *, obj,
158
 
                  Properties::VIRTUAL,
159
 
                  __bool__isSameKindAs__C5_osg_Object_P1,
160
 
                  "",
161
 
                  "");
162
 
        I_Method0(const char *, libraryName,
163
 
                  Properties::VIRTUAL,
164
 
                  __C5_char_P1__libraryName,
165
 
                  "return the name of the object's library. ",
166
 
                  "Must be defined by derived classes. The OpenSceneGraph convention is that the namespace of a library is the same as the library name. ");
167
 
        I_Method0(const char *, className,
168
 
                  Properties::VIRTUAL,
169
 
                  __C5_char_P1__className,
170
 
                  "return the name of the object's class type. ",
171
 
                  "Must be defined by derived classes. ");
172
 
        I_Method1(void, setFileName, IN, const std::string &, filename,
173
 
                  Properties::VIRTUAL,
174
 
                  __void__setFileName__C5_std_string_R1,
175
 
                  "Set the file name of the data associated with this layer. ",
176
 
                  "");
177
 
        I_Method0(const std::string &, getFileName,
178
 
                  Properties::VIRTUAL,
179
 
                  __C5_std_string_R1__getFileName,
180
 
                  "Get the file name of the layer. ",
181
 
                  "");
182
 
        I_Method1(void, setImage, IN, osg::Image *, image,
183
 
                  Properties::NON_VIRTUAL,
184
 
                  __void__setImage__osg_Image_P1,
185
 
                  "",
186
 
                  "");
187
 
        I_Method0(osg::Image *, getImage,
188
 
                  Properties::VIRTUAL,
189
 
                  __osg_Image_P1__getImage,
190
 
                  "Return image associated with layer. ",
191
 
                  "");
192
 
        I_Method0(const osg::Image *, getImage,
193
 
                  Properties::VIRTUAL,
194
 
                  __C5_osg_Image_P1__getImage,
195
 
                  "Return const image associated with layer. ",
196
 
                  "");
197
 
        I_Method2(bool, computeMinMax, IN, osg::Vec4 &, min, IN, osg::Vec4 &, max,
198
 
                  Properties::NON_VIRTUAL,
199
 
                  __bool__computeMinMax__osg_Vec4_R1__osg_Vec4_R1,
200
 
                  "Compute the min and max pixel colors. ",
201
 
                  "");
202
 
        I_Method2(void, offsetAndScaleImage, IN, const osg::Vec4 &, offset, IN, const osg::Vec4 &, scale,
203
 
                  Properties::NON_VIRTUAL,
204
 
                  __void__offsetAndScaleImage__C5_osg_Vec4_R1__C5_osg_Vec4_R1,
205
 
                  "Apply color transformation to pixels using c' = offset + c * scale . ",
206
 
                  "");
207
 
        I_Method0(void, rescaleToZeroToOneRange,
208
 
                  Properties::NON_VIRTUAL,
209
 
                  __void__rescaleToZeroToOneRange,
210
 
                  "Compute the min max range of the image, and then remap this to a 0 to 1 range. ",
211
 
                  "");
212
 
        I_Method0(void, translateMinToZero,
213
 
                  Properties::NON_VIRTUAL,
214
 
                  __void__translateMinToZero,
215
 
                  "Compute the min color component of the image and then translate and pixels by this offset to make the new min component 0. ",
216
 
                  "");
217
 
        I_Method0(bool, requiresUpdateTraversal,
218
 
                  Properties::VIRTUAL,
219
 
                  __bool__requiresUpdateTraversal,
220
 
                  "Specify whether ImageLayer requires update traversal. ",
221
 
                  "");
222
 
        I_Method1(void, update, IN, osg::NodeVisitor &, x,
223
 
                  Properties::VIRTUAL,
224
 
                  __void__update__osg_NodeVisitor_R1,
225
 
                  "Call update on the Layer. ",
226
 
                  "");
227
 
        I_Method0(void, dirty,
228
 
                  Properties::VIRTUAL,
229
 
                  __void__dirty,
230
 
                  "increment the modified count. ",
231
 
                  "\" ");
232
 
        I_Method1(void, setModifiedCount, IN, unsigned int, value,
233
 
                  Properties::VIRTUAL,
234
 
                  __void__setModifiedCount__unsigned_int,
235
 
                  "Set the modified count value. ",
236
 
                  "");
237
 
        I_Method0(unsigned int, getModifiedCount,
238
 
                  Properties::VIRTUAL,
239
 
                  __unsigned_int__getModifiedCount,
240
 
                  "Get modified count value. ",
241
 
                  "");
242
 
        I_SimpleProperty(const std::string &, FileName, 
243
 
                         __C5_std_string_R1__getFileName, 
244
 
                         __void__setFileName__C5_std_string_R1);
245
 
        I_SimpleProperty(osg::Image *, Image, 
246
 
                         __osg_Image_P1__getImage, 
247
 
                         __void__setImage__osg_Image_P1);
248
 
        I_SimpleProperty(unsigned int, ModifiedCount, 
249
 
                         __unsigned_int__getModifiedCount, 
250
 
                         __void__setModifiedCount__unsigned_int);
251
 
END_REFLECTOR
252
 
 
253
 
BEGIN_OBJECT_REFLECTOR(osgVolume::Layer)
254
 
        I_DeclaringFile("osgVolume/Layer");
255
 
        I_BaseType(osg::Object);
256
 
        I_Constructor0(____Layer,
257
 
                       "",
258
 
                       "");
259
 
        I_ConstructorWithDefaults2(IN, const osgVolume::Layer &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY,
260
 
                                   ____Layer__C5_Layer_R1__C5_osg_CopyOp_R1,
261
 
                                   "Copy constructor using CopyOp to manage deep vs shallow copy. ",
262
 
                                   "");
263
 
        I_Method0(osg::Object *, cloneType,
264
 
                  Properties::VIRTUAL,
265
 
                  __osg_Object_P1__cloneType,
266
 
                  "Clone the type of an object, with Object* return type. ",
267
 
                  "Must be defined by derived classes. ");
268
 
        I_Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop,
269
 
                  Properties::VIRTUAL,
270
 
                  __osg_Object_P1__clone__C5_osg_CopyOp_R1,
271
 
                  "Clone an object, with Object* return type. ",
272
 
                  "Must be defined by derived classes. ");
273
 
        I_Method1(bool, isSameKindAs, IN, const osg::Object *, obj,
274
 
                  Properties::VIRTUAL,
275
 
                  __bool__isSameKindAs__C5_osg_Object_P1,
276
 
                  "",
277
 
                  "");
278
 
        I_Method0(const char *, libraryName,
279
 
                  Properties::VIRTUAL,
280
 
                  __C5_char_P1__libraryName,
281
 
                  "return the name of the object's library. ",
282
 
                  "Must be defined by derived classes. The OpenSceneGraph convention is that the namespace of a library is the same as the library name. ");
283
 
        I_Method0(const char *, className,
284
 
                  Properties::VIRTUAL,
285
 
                  __C5_char_P1__className,
286
 
                  "return the name of the object's class type. ",
287
 
                  "Must be defined by derived classes. ");
288
 
        I_Method1(void, setFileName, IN, const std::string &, filename,
289
 
                  Properties::VIRTUAL,
290
 
                  __void__setFileName__C5_std_string_R1,
291
 
                  "Set the file name of the data associated with this layer. ",
292
 
                  "");
293
 
        I_Method0(const std::string &, getFileName,
294
 
                  Properties::VIRTUAL,
295
 
                  __C5_std_string_R1__getFileName,
296
 
                  "Get the file name of the layer. ",
297
 
                  "");
298
 
        I_Method1(void, setLocator, IN, osgVolume::Locator *, locator,
299
 
                  Properties::NON_VIRTUAL,
300
 
                  __void__setLocator__Locator_P1,
301
 
                  "",
302
 
                  "");
303
 
        I_Method0(osgVolume::Locator *, getLocator,
304
 
                  Properties::NON_VIRTUAL,
305
 
                  __Locator_P1__getLocator,
306
 
                  "",
307
 
                  "");
308
 
        I_Method0(const osgVolume::Locator *, getLocator,
309
 
                  Properties::NON_VIRTUAL,
310
 
                  __C5_Locator_P1__getLocator,
311
 
                  "",
312
 
                  "");
313
 
        I_Method1(void, setDefaultValue, IN, const osg::Vec4 &, value,
314
 
                  Properties::NON_VIRTUAL,
315
 
                  __void__setDefaultValue__C5_osg_Vec4_R1,
316
 
                  "",
317
 
                  "");
318
 
        I_Method0(const osg::Vec4 &, getDefaultValue,
319
 
                  Properties::NON_VIRTUAL,
320
 
                  __C5_osg_Vec4_R1__getDefaultValue,
321
 
                  "",
322
 
                  "");
323
 
        I_Method1(void, setMinFilter, IN, osg::Texture::FilterMode, filter,
324
 
                  Properties::NON_VIRTUAL,
325
 
                  __void__setMinFilter__osg_Texture_FilterMode,
326
 
                  "Set the minification texture filter to use when do texture associated with this layer. ",
327
 
                  "");
328
 
        I_Method0(osg::Texture::FilterMode, getMinFilter,
329
 
                  Properties::NON_VIRTUAL,
330
 
                  __osg_Texture_FilterMode__getMinFilter,
331
 
                  "Get the minification texture filter to use when do texture associated with this layer. ",
332
 
                  "");
333
 
        I_Method1(void, setMagFilter, IN, osg::Texture::FilterMode, filter,
334
 
                  Properties::NON_VIRTUAL,
335
 
                  __void__setMagFilter__osg_Texture_FilterMode,
336
 
                  "Set the magniification texture filter to use when do texture associated with this layer. ",
337
 
                  "");
338
 
        I_Method0(osg::Texture::FilterMode, getMagFilter,
339
 
                  Properties::NON_VIRTUAL,
340
 
                  __osg_Texture_FilterMode__getMagFilter,
341
 
                  "Get the magnification texture filter to use when do texture associated with this layer. ",
342
 
                  "");
343
 
        I_Method0(osg::Image *, getImage,
344
 
                  Properties::VIRTUAL,
345
 
                  __osg_Image_P1__getImage,
346
 
                  "Return image associated with layer if supported. ",
347
 
                  "");
348
 
        I_Method0(const osg::Image *, getImage,
349
 
                  Properties::VIRTUAL,
350
 
                  __C5_osg_Image_P1__getImage,
351
 
                  "Return const image associated with layer if supported. ",
352
 
                  "");
353
 
        I_Method1(void, setProperty, IN, osgVolume::Property *, property,
354
 
                  Properties::NON_VIRTUAL,
355
 
                  __void__setProperty__Property_P1,
356
 
                  "Set the Property (or Properties via the CompositeProperty) that informs the VolumeTechnique how this layer should be rendered. ",
357
 
                  "");
358
 
        I_Method0(osgVolume::Property *, getProperty,
359
 
                  Properties::NON_VIRTUAL,
360
 
                  __Property_P1__getProperty,
361
 
                  "Get the Property that informs the VolumeTechnique how this layer should be rendered. ",
362
 
                  "");
363
 
        I_Method0(const osgVolume::Property *, getProperty,
364
 
                  Properties::NON_VIRTUAL,
365
 
                  __C5_Property_P1__getProperty,
366
 
                  "Get the const Property that informs the VolumeTechnique how this layer should be rendered. ",
367
 
                  "");
368
 
        I_Method1(void, addProperty, IN, osgVolume::Property *, property,
369
 
                  Properties::NON_VIRTUAL,
370
 
                  __void__addProperty__Property_P1,
371
 
                  "Add a property, automatically creating a CompositePorperty if one isn't already assigned. ",
372
 
                  "");
373
 
        I_Method0(bool, requiresUpdateTraversal,
374
 
                  Properties::VIRTUAL,
375
 
                  __bool__requiresUpdateTraversal,
376
 
                  "Specify whether ImageLayer requires update traversal. ",
377
 
                  "");
378
 
        I_Method1(void, update, IN, osg::NodeVisitor &, x,
379
 
                  Properties::VIRTUAL,
380
 
                  __void__update__osg_NodeVisitor_R1,
381
 
                  "Call update on the Layer. ",
382
 
                  "");
383
 
        I_Method0(void, dirty,
384
 
                  Properties::VIRTUAL,
385
 
                  __void__dirty,
386
 
                  "increment the modified count. ",
387
 
                  "\" ");
388
 
        I_Method1(void, setModifiedCount, IN, unsigned, int,
389
 
                  Properties::VIRTUAL,
390
 
                  __void__setModifiedCount__unsigned,
391
 
                  "Set the modified count value. ",
392
 
                  "");
393
 
        I_Method0(unsigned int, getModifiedCount,
394
 
                  Properties::VIRTUAL,
395
 
                  __unsigned_int__getModifiedCount,
396
 
                  "Get modified count value. ",
397
 
                  "");
398
 
        I_Method0(osg::BoundingSphere, computeBound,
399
 
                  Properties::VIRTUAL,
400
 
                  __osg_BoundingSphere__computeBound,
401
 
                  "",
402
 
                  "");
403
 
        I_SimpleProperty(const osg::Vec4 &, DefaultValue, 
404
 
                         __C5_osg_Vec4_R1__getDefaultValue, 
405
 
                         __void__setDefaultValue__C5_osg_Vec4_R1);
406
 
        I_SimpleProperty(const std::string &, FileName, 
407
 
                         __C5_std_string_R1__getFileName, 
408
 
                         __void__setFileName__C5_std_string_R1);
409
 
        I_SimpleProperty(osg::Image *, Image, 
410
 
                         __osg_Image_P1__getImage, 
411
 
                         0);
412
 
        I_SimpleProperty(osgVolume::Locator *, Locator, 
413
 
                         __Locator_P1__getLocator, 
414
 
                         __void__setLocator__Locator_P1);
415
 
        I_SimpleProperty(osg::Texture::FilterMode, MagFilter, 
416
 
                         __osg_Texture_FilterMode__getMagFilter, 
417
 
                         __void__setMagFilter__osg_Texture_FilterMode);
418
 
        I_SimpleProperty(osg::Texture::FilterMode, MinFilter, 
419
 
                         __osg_Texture_FilterMode__getMinFilter, 
420
 
                         __void__setMinFilter__osg_Texture_FilterMode);
421
 
        I_SimpleProperty(unsigned, ModifiedCount, 
422
 
                         0, 
423
 
                         __void__setModifiedCount__unsigned);
424
 
        I_SimpleProperty(osgVolume::Property *, Property, 
425
 
                         __Property_P1__getProperty, 
426
 
                         __void__setProperty__Property_P1);
427
 
END_REFLECTOR
428