root/OpenSceneGraph/trunk/include/osg/Array @ 12608

Revision 12608, 18.1 kB (checked in by robert, 3 years ago)

From Ryan Pavlik, "I have successfully compiled OpenSceneGraph trunk using the Clang compiler (using a recent trunk build of llvm and clang, haven't tested an older release). The attached files contain the change shown in the diff below, which was required to finish the build with Clang. It fixes an issue with two-phase name lookup - there's more information here http://blog.llvm.org/2009/12/dreaded-two-phase-name-lookup.html
"

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
2 *
3 * This library is open source and may be redistributed and/or modified under 
4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
5 * (at your option) any later version.  The full license is in LICENSE file
6 * included with this distribution, and on the openscenegraph.org website.
7 *
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 * OpenSceneGraph Public License for more details.
12*/
13
14#ifndef OSG_ARRAY
15#define OSG_ARRAY 1
16
17#include <osg/MixinVector>
18
19#include <osg/Vec2>
20#include <osg/Vec3>
21#include <osg/Vec4>
22#include <osg/Vec2d>
23#include <osg/Vec3d>
24#include <osg/Vec4d>
25#include <osg/Vec4ub>
26#include <osg/Vec2s>
27#include <osg/Vec3s>
28#include <osg/Vec4s>
29#include <osg/Vec2b>
30#include <osg/Vec3b>
31#include <osg/Vec4b>
32#include <osg/Matrix>
33
34#include <osg/BufferObject>
35
36#include <osg/Object>
37#include <osg/GL>
38
39namespace osg {
40
41class ArrayVisitor;
42class ConstArrayVisitor;
43
44class ValueVisitor;
45class ConstValueVisitor;
46
47class OSG_EXPORT Array : public BufferData
48{
49
50    public:
51   
52        enum Type
53        {
54            ArrayType = 0,
55            ByteArrayType     = 1,
56            ShortArrayType    = 2,
57            IntArrayType      = 3,
58            UByteArrayType    = 4,
59            UShortArrayType   = 5,
60            UIntArrayType     = 6,
61            Vec4ubArrayType   = 7,
62            FloatArrayType    = 8,
63            Vec2ArrayType     = 9,
64            Vec3ArrayType     = 10,
65            Vec4ArrayType     = 11,
66            Vec2sArrayType    = 12,
67            Vec3sArrayType    = 13,
68            Vec4sArrayType    = 14,
69            Vec2bArrayType    = 15,
70            Vec3bArrayType    = 16,
71            Vec4bArrayType    = 17,
72            DoubleArrayType   = 18,
73            Vec2dArrayType    = 19,
74            Vec3dArrayType    = 20,
75            Vec4dArrayType    = 21,
76            MatrixArrayType   = 22           
77        };
78
79        Array(Type arrayType=ArrayType,GLint dataSize=0,GLenum dataType=0):
80            _arrayType(arrayType),
81            _dataSize(dataSize),
82            _dataType(dataType) {}
83
84        Array(const Array& array,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
85            BufferData(array,copyop),
86            _arrayType(array._arrayType),
87            _dataSize(array._dataSize),
88            _dataType(array._dataType) {}
89
90        virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const Array*>(obj)!=NULL; }
91        virtual const char* libraryName() const { return "osg"; }
92        virtual const char* className() const;
93
94        virtual void accept(ArrayVisitor&) = 0;
95        virtual void accept(ConstArrayVisitor&) const = 0;
96
97        virtual void accept(unsigned int index,ValueVisitor&) = 0;
98        virtual void accept(unsigned int index,ConstValueVisitor&) const = 0;
99
100        /** Return -1 if lhs element is less than rhs element, 0 if equal,
101          * 1 if lhs element is greater than rhs element. */
102        virtual int compare(unsigned int lhs,unsigned int rhs) const = 0;
103
104        Type                    getType() const { return _arrayType; }
105        GLint                   getDataSize() const { return _dataSize; }
106        GLenum                  getDataType() const { return _dataType; }
107        virtual const GLvoid*   getDataPointer() const = 0;
108        virtual unsigned int    getTotalDataSize() const = 0;
109        virtual unsigned int    getNumElements() const = 0;
110
111        /** Frees unused space on this vector - i.e. the difference between size() and max_size() of the underlying vector.*/
112        virtual void trim() {}
113
114        /** Set the VertexBufferObject.*/
115        inline void setVertexBufferObject(osg::VertexBufferObject* vbo) { setBufferObject(vbo); }
116
117        /** Get the VertexBufferObject. If no VBO is assigned returns NULL*/
118        inline osg::VertexBufferObject* getVertexBufferObject() { return dynamic_cast<osg::VertexBufferObject*>(_bufferObject.get()); }
119
120        /** Get the const VertexBufferObject. If no VBO is assigned returns NULL*/
121        inline const osg::VertexBufferObject* getVertexBufferObject() const { return dynamic_cast<const osg::VertexBufferObject*>(_bufferObject.get());  }
122
123    protected:
124
125        virtual ~Array() {}
126
127        Type                                    _arrayType;
128        GLint                                   _dataSize;
129        GLenum                                  _dataType;
130};
131
132template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
133class TemplateArray : public Array, public MixinVector<T>
134{
135    public:
136
137        TemplateArray() : Array(ARRAYTYPE,DataSize,DataType) {}
138
139        TemplateArray(const TemplateArray& ta,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
140            Array(ta,copyop),
141            MixinVector<T>(ta) {}
142
143        TemplateArray(unsigned int no) :
144            Array(ARRAYTYPE,DataSize,DataType),
145            MixinVector<T>(no) {}
146
147        TemplateArray(unsigned int no,const T* ptr) :
148            Array(ARRAYTYPE,DataSize,DataType),
149            MixinVector<T>(ptr,ptr+no) {}
150
151        template <class InputIterator>
152        TemplateArray(InputIterator first,InputIterator last) :
153            Array(ARRAYTYPE,DataSize,DataType),
154            MixinVector<T>(first,last) {}       
155
156        TemplateArray& operator = (const TemplateArray& array)
157        {
158            if (this==&array) return *this;
159            this->assign(array.begin(),array.end());
160            return *this;
161        }
162
163        virtual Object* cloneType() const { return new TemplateArray(); }
164        virtual Object* clone(const CopyOp& copyop) const { return new TemplateArray(*this,copyop); }       
165
166        inline virtual void accept(ArrayVisitor& av);
167        inline virtual void accept(ConstArrayVisitor& av) const;
168
169        inline virtual void accept(unsigned int index,ValueVisitor& vv);
170        inline virtual void accept(unsigned int index,ConstValueVisitor& vv) const;
171
172        virtual int compare(unsigned int lhs,unsigned int rhs) const
173        {
174            const T& elem_lhs = (*this)[lhs];
175            const T& elem_rhs = (*this)[rhs];
176            if (elem_lhs<elem_rhs) return -1;
177            if (elem_rhs<elem_lhs) return 1;
178            return 0;
179        }
180
181        /** Frees unused space on this vector - i.e. the difference between size() and max_size() of the underlying vector.*/
182        virtual void trim()
183        {
184            MixinVector<T>( *this ).swap( *this );
185        }
186
187        virtual const GLvoid*   getDataPointer() const { if (!this->empty()) return &this->front(); else return 0; }
188        virtual unsigned int    getTotalDataSize() const { return static_cast<unsigned int>(this->size()*sizeof(T)); }
189        virtual unsigned int    getNumElements() const { return static_cast<unsigned int>(this->size()); }
190
191        typedef T ElementDataType; // expose T
192
193    protected:
194   
195        virtual ~TemplateArray() {}
196};
197
198class OSG_EXPORT IndexArray : public Array
199{
200
201    public:
202
203        IndexArray(Type arrayType=ArrayType,GLint dataSize=0,GLenum dataType=0):
204            Array(arrayType,dataSize,dataType) {}
205
206        IndexArray(const Array& array,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
207            Array(array,copyop) {}
208
209        virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const IndexArray*>(obj)!=NULL; }
210
211        virtual unsigned int index(unsigned int pos) const = 0;
212
213    protected:
214
215        virtual ~IndexArray() {}
216};
217
218template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
219class TemplateIndexArray : public IndexArray, public MixinVector<T>
220{
221    public:
222
223        TemplateIndexArray() : IndexArray(ARRAYTYPE,DataSize,DataType) {}
224
225        TemplateIndexArray(const TemplateIndexArray& ta,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
226            IndexArray(ta,copyop),
227            MixinVector<T>(ta) {}
228
229        TemplateIndexArray(unsigned int no) :
230            IndexArray(ARRAYTYPE,DataSize,DataType),
231            MixinVector<T>(no) {}
232
233        TemplateIndexArray(unsigned int no,T* ptr) :
234            IndexArray(ARRAYTYPE,DataSize,DataType),
235            MixinVector<T>(ptr,ptr+no) {}
236
237        template <class InputIterator>
238        TemplateIndexArray(InputIterator first,InputIterator last) :
239            IndexArray(ARRAYTYPE,DataSize,DataType),
240            MixinVector<T>(first,last) {}       
241
242        TemplateIndexArray& operator = (const TemplateIndexArray& array)
243        {
244            if (this==&array) return *this;
245            this->assign(array.begin(),array.end());
246            return *this;
247        }
248
249        virtual Object* cloneType() const { return new TemplateIndexArray(); }
250        virtual Object* clone(const CopyOp& copyop) const { return new TemplateIndexArray(*this,copyop); }       
251
252        inline virtual void accept(ArrayVisitor& av);
253        inline virtual void accept(ConstArrayVisitor& av) const;
254
255        inline virtual void accept(unsigned int index,ValueVisitor& vv);
256        inline virtual void accept(unsigned int index,ConstValueVisitor& vv) const;
257
258        virtual int compare(unsigned int lhs,unsigned int rhs) const
259        {
260            const T& elem_lhs = (*this)[lhs];
261            const T& elem_rhs = (*this)[rhs];
262            if (elem_lhs<elem_rhs) return -1;
263            if (elem_rhs<elem_lhs) return 1;
264            return 0;
265        }
266
267        /** Frees unused space on this vector - i.e. the difference between size() and max_size() of the underlying vector.*/
268        virtual void trim()
269        {
270            MixinVector<T>( *this ).swap( *this );
271        }
272
273        virtual const GLvoid*   getDataPointer() const { if (!this->empty()) return &this->front(); else return 0; }
274        virtual unsigned int    getTotalDataSize() const { return static_cast<unsigned int>(this->size()*sizeof(T)); }
275        virtual unsigned int    getNumElements() const { return static_cast<unsigned int>(this->size()); }
276
277        virtual unsigned int    index(unsigned int pos) const { return (*this)[pos]; }
278
279        typedef T ElementDataType; // expose T
280
281    protected:
282
283        virtual ~TemplateIndexArray() {}
284};
285
286typedef TemplateIndexArray<GLbyte,Array::ByteArrayType,1,GL_BYTE>               ByteArray;
287typedef TemplateIndexArray<GLshort,Array::ShortArrayType,1,GL_SHORT>            ShortArray;
288typedef TemplateIndexArray<GLint,Array::IntArrayType,1,GL_INT>                  IntArray;
289typedef TemplateIndexArray<GLubyte,Array::UByteArrayType,1,GL_UNSIGNED_BYTE>    UByteArray;
290typedef TemplateIndexArray<GLushort,Array::UShortArrayType,1,GL_UNSIGNED_SHORT> UShortArray;
291typedef TemplateIndexArray<GLuint,Array::UIntArrayType,1,GL_UNSIGNED_INT>       UIntArray;
292
293typedef TemplateArray<GLfloat,Array::FloatArrayType,1,GL_FLOAT>                 FloatArray;
294
295typedef TemplateArray<Vec2,Array::Vec2ArrayType,2,GL_FLOAT>                     Vec2Array;
296typedef TemplateArray<Vec3,Array::Vec3ArrayType,3,GL_FLOAT>                     Vec3Array;
297typedef TemplateArray<Vec4,Array::Vec4ArrayType,4,GL_FLOAT>                     Vec4Array;
298
299typedef TemplateArray<Vec4ub,Array::Vec4ubArrayType,4,GL_UNSIGNED_BYTE>         Vec4ubArray;
300
301typedef TemplateArray<Vec2s,Array::Vec2sArrayType,2,GL_SHORT>                   Vec2sArray;
302typedef TemplateArray<Vec3s,Array::Vec3sArrayType,3,GL_SHORT>                   Vec3sArray;
303typedef TemplateArray<Vec4s,Array::Vec4sArrayType,4,GL_SHORT>                   Vec4sArray;
304
305typedef TemplateArray<Vec2b,Array::Vec2bArrayType,2,GL_BYTE>                    Vec2bArray;
306typedef TemplateArray<Vec3b,Array::Vec3bArrayType,3,GL_BYTE>                    Vec3bArray;
307typedef TemplateArray<Vec4b,Array::Vec4bArrayType,4,GL_BYTE>                    Vec4bArray;
308
309typedef TemplateArray<GLdouble,Array::DoubleArrayType,1,GL_DOUBLE>               DoubleArray;
310typedef TemplateArray<Vec2d,Array::Vec2dArrayType,2,GL_DOUBLE>                   Vec2dArray;
311typedef TemplateArray<Vec3d,Array::Vec3dArrayType,3,GL_DOUBLE>                   Vec3dArray;
312typedef TemplateArray<Vec4d,Array::Vec4dArrayType,4,GL_DOUBLE>                   Vec4dArray;
313
314typedef TemplateArray<Matrixf,Array::MatrixArrayType,16,GL_FLOAT>                MatrixfArray;
315
316
317class ArrayVisitor
318{
319    public:
320        ArrayVisitor() {}
321        virtual ~ArrayVisitor() {}
322       
323        virtual void apply(Array&) {}
324        virtual void apply(ByteArray&) {}
325        virtual void apply(ShortArray&) {}
326        virtual void apply(IntArray&) {}
327        virtual void apply(UByteArray&) {}
328        virtual void apply(UShortArray&) {}
329        virtual void apply(UIntArray&) {}
330        virtual void apply(FloatArray&) {}
331        virtual void apply(DoubleArray&) {}
332
333        virtual void apply(Vec2Array&) {}
334        virtual void apply(Vec3Array&) {}
335        virtual void apply(Vec4Array&) {}
336       
337        virtual void apply(Vec4ubArray&) {}
338
339        virtual void apply(Vec2bArray&) {}       
340        virtual void apply(Vec3bArray&) {}       
341        virtual void apply(Vec4bArray&) {}       
342
343        virtual void apply(Vec2sArray&) {}
344        virtual void apply(Vec3sArray&) {}
345        virtual void apply(Vec4sArray&) {}
346
347        virtual void apply(Vec2dArray&) {}
348        virtual void apply(Vec3dArray&) {}
349        virtual void apply(Vec4dArray&) {}
350       
351        virtual void apply(MatrixfArray&) {}
352};
353
354class ConstArrayVisitor
355{
356    public:
357        ConstArrayVisitor() {}
358        virtual ~ConstArrayVisitor() {}
359       
360        virtual void apply(const Array&) {}
361        virtual void apply(const ByteArray&) {}
362        virtual void apply(const ShortArray&) {}
363        virtual void apply(const IntArray&) {}
364        virtual void apply(const UByteArray&) {}
365        virtual void apply(const UShortArray&) {}
366        virtual void apply(const UIntArray&) {}
367        virtual void apply(const FloatArray&) {}
368        virtual void apply(const DoubleArray&) {}
369
370        virtual void apply(const Vec2Array&) {}
371        virtual void apply(const Vec3Array&) {}
372        virtual void apply(const Vec4Array&) {}
373
374        virtual void apply(const Vec4ubArray&) {}
375
376        virtual void apply(const Vec2bArray&) {}       
377        virtual void apply(const Vec3bArray&) {}       
378        virtual void apply(const Vec4bArray&) {}       
379
380        virtual void apply(const Vec2sArray&) {}
381        virtual void apply(const Vec3sArray&) {}
382        virtual void apply(const Vec4sArray&) {}
383
384        virtual void apply(const Vec2dArray&) {}
385        virtual void apply(const Vec3dArray&) {}
386        virtual void apply(const Vec4dArray&) {}
387       
388        virtual void apply(const MatrixfArray&) {}
389};
390
391
392class ValueVisitor
393{
394    public:
395        ValueVisitor() {}
396        virtual ~ValueVisitor() {}
397       
398        virtual void apply(GLbyte&) {}
399        virtual void apply(GLshort&) {}
400        virtual void apply(GLint&) {}
401        virtual void apply(GLushort&) {}
402        virtual void apply(GLubyte&) {}
403        virtual void apply(GLuint&) {}
404        virtual void apply(GLfloat&) {}
405        virtual void apply(GLdouble&) {}
406       
407       
408        virtual void apply(Vec2&) {}
409        virtual void apply(Vec3&) {}
410        virtual void apply(Vec4&) {}
411       
412        virtual void apply(Vec4ub&) {}
413
414        virtual void apply(Vec2b&) {}       
415        virtual void apply(Vec3b&) {}       
416        virtual void apply(Vec4b&) {}       
417
418        virtual void apply(Vec2s&) {}
419        virtual void apply(Vec3s&) {}
420        virtual void apply(Vec4s&) {}
421
422        virtual void apply(Vec2d&) {}
423        virtual void apply(Vec3d&) {}
424        virtual void apply(Vec4d&) {}
425       
426        virtual void apply(Matrixf&) {}
427};
428
429class ConstValueVisitor
430{
431    public:
432        ConstValueVisitor() {}
433        virtual ~ConstValueVisitor() {}
434       
435        virtual void apply(const GLbyte&) {}
436        virtual void apply(const GLshort&) {}
437        virtual void apply(const GLint&) {}
438        virtual void apply(const GLushort&) {}
439        virtual void apply(const GLubyte&) {}
440        virtual void apply(const GLuint&) {}
441        virtual void apply(const GLfloat&) {}
442        virtual void apply(const GLdouble&) {}
443
444        virtual void apply(const Vec4ub&) {}
445
446        virtual void apply(const Vec2&) {}
447        virtual void apply(const Vec3&) {}
448        virtual void apply(const Vec4&) {}
449
450        virtual void apply(const Vec2b&) {}
451        virtual void apply(const Vec3b&) {}
452        virtual void apply(const Vec4b&) {}       
453       
454        virtual void apply(const Vec2s&) {}
455        virtual void apply(const Vec3s&) {}
456        virtual void apply(const Vec4s&) {}
457       
458        virtual void apply(const Vec2d&) {}
459        virtual void apply(const Vec3d&) {}
460        virtual void apply(const Vec4d&) {}
461       
462        virtual void apply(const Matrixf&) {}
463};
464
465template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
466inline void TemplateArray<T,ARRAYTYPE,DataSize,DataType>::accept(ArrayVisitor& av) { av.apply(*this); }
467
468template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
469inline void TemplateArray<T,ARRAYTYPE,DataSize,DataType>::accept(ConstArrayVisitor& av) const { av.apply(*this); }
470
471template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
472inline void TemplateArray<T,ARRAYTYPE,DataSize,DataType>::accept(unsigned int index,ValueVisitor& vv) { vv.apply( (*this)[index] ); }
473
474template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
475inline void TemplateArray<T,ARRAYTYPE,DataSize,DataType>::accept(unsigned int index,ConstValueVisitor& vv) const {  vv.apply( (*this)[index] );}
476
477template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
478inline void TemplateIndexArray<T,ARRAYTYPE,DataSize,DataType>::accept(ArrayVisitor& av) { av.apply(*this); }
479
480template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
481inline void TemplateIndexArray<T,ARRAYTYPE,DataSize,DataType>::accept(ConstArrayVisitor& av) const { av.apply(*this); }
482
483template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
484inline void TemplateIndexArray<T,ARRAYTYPE,DataSize,DataType>::accept(unsigned int index,ValueVisitor& vv) { vv.apply( (*this)[index] ); }
485
486template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
487inline void TemplateIndexArray<T,ARRAYTYPE,DataSize,DataType>::accept(unsigned int index,ConstValueVisitor& vv) const {  vv.apply( (*this)[index] );}
488
489}
490
491#endif
Note: See TracBrowser for help on using the browser.