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

Revision 10061, 19.1 kB (checked in by robert, 6 years ago)

Changed parameter for T* to const T*.

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