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

Revision 12912, 18.2 kB (checked in by robert, 3 years ago)

Added support for using GL_UNPACK_ROW_LENGTH in conjunction with texture's + osg::Image via new RowLength?
parameter in osg::Image. To support this Image::setData(..) now has a new optional rowLength parameter which
defaults to 0, which provides the original behaviour, Image::setRowLength(int) and int Image::getRowLength() are also provided.

With the introduction of RowLength? support in osg::Image it is now possible to create a sub image where
the t size of the image are smaller than the row length, useful for when you have a large image on the CPU
and which to use a small portion of it on the GPU. However, when these sub images are created the data
within the image is no longer contiguous so data access can no longer assume that all the data is in
one block. The new method Image::isDataContiguous() enables the user to check whether the data is contiguous,
and if not one can either access the data row by row using Image::data(column,row,image) accessor, or use the
new Image::DataIterator? for stepping through each block on memory assocatied with the image.

To support the possibility of non contiguous osg::Image usage of image objects has had to be updated to
check DataContiguous? and handle the case or use access via the DataIerator? or by row by row. To achieve
this a relatively large number of files has had to be modified, in particular the texture classes and
image plugins that doing writing.

  • 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
108        virtual osg::Array* asArray() { return this; }
109        virtual const osg::Array* asArray() const { return this; }
110
111        virtual const GLvoid*   getDataPointer() const = 0;
112        virtual unsigned int    getTotalDataSize() const = 0;
113        virtual unsigned int    getNumElements() const = 0;
114
115        /** Frees unused space on this vector - i.e. the difference between size() and max_size() of the underlying vector.*/
116        virtual void trim() {}
117
118        /** Set the VertexBufferObject.*/
119        inline void setVertexBufferObject(osg::VertexBufferObject* vbo) { setBufferObject(vbo); }
120
121        /** Get the VertexBufferObject. If no VBO is assigned returns NULL*/
122        inline osg::VertexBufferObject* getVertexBufferObject() { return dynamic_cast<osg::VertexBufferObject*>(_bufferObject.get()); }
123
124        /** Get the const VertexBufferObject. If no VBO is assigned returns NULL*/
125        inline const osg::VertexBufferObject* getVertexBufferObject() const { return dynamic_cast<const osg::VertexBufferObject*>(_bufferObject.get());  }
126
127    protected:
128
129        virtual ~Array() {}
130
131        Type                                    _arrayType;
132        GLint                                   _dataSize;
133        GLenum                                  _dataType;
134};
135
136template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
137class TemplateArray : public Array, public MixinVector<T>
138{
139    public:
140
141        TemplateArray() : Array(ARRAYTYPE,DataSize,DataType) {}
142
143        TemplateArray(const TemplateArray& ta,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
144            Array(ta,copyop),
145            MixinVector<T>(ta) {}
146
147        TemplateArray(unsigned int no) :
148            Array(ARRAYTYPE,DataSize,DataType),
149            MixinVector<T>(no) {}
150
151        TemplateArray(unsigned int no,const T* ptr) :
152            Array(ARRAYTYPE,DataSize,DataType),
153            MixinVector<T>(ptr,ptr+no) {}
154
155        template <class InputIterator>
156        TemplateArray(InputIterator first,InputIterator last) :
157            Array(ARRAYTYPE,DataSize,DataType),
158            MixinVector<T>(first,last) {}       
159
160        TemplateArray& operator = (const TemplateArray& array)
161        {
162            if (this==&array) return *this;
163            this->assign(array.begin(),array.end());
164            return *this;
165        }
166
167        virtual Object* cloneType() const { return new TemplateArray(); }
168        virtual Object* clone(const CopyOp& copyop) const { return new TemplateArray(*this,copyop); }       
169
170        inline virtual void accept(ArrayVisitor& av);
171        inline virtual void accept(ConstArrayVisitor& av) const;
172
173        inline virtual void accept(unsigned int index,ValueVisitor& vv);
174        inline virtual void accept(unsigned int index,ConstValueVisitor& vv) const;
175
176        virtual int compare(unsigned int lhs,unsigned int rhs) const
177        {
178            const T& elem_lhs = (*this)[lhs];
179            const T& elem_rhs = (*this)[rhs];
180            if (elem_lhs<elem_rhs) return -1;
181            if (elem_rhs<elem_lhs) return 1;
182            return 0;
183        }
184
185        /** Frees unused space on this vector - i.e. the difference between size() and max_size() of the underlying vector.*/
186        virtual void trim()
187        {
188            MixinVector<T>( *this ).swap( *this );
189        }
190
191        virtual const GLvoid*   getDataPointer() const { if (!this->empty()) return &this->front(); else return 0; }
192        virtual unsigned int    getTotalDataSize() const { return static_cast<unsigned int>(this->size()*sizeof(T)); }
193        virtual unsigned int    getNumElements() const { return static_cast<unsigned int>(this->size()); }
194
195        typedef T ElementDataType; // expose T
196
197    protected:
198   
199        virtual ~TemplateArray() {}
200};
201
202class OSG_EXPORT IndexArray : public Array
203{
204
205    public:
206
207        IndexArray(Type arrayType=ArrayType,GLint dataSize=0,GLenum dataType=0):
208            Array(arrayType,dataSize,dataType) {}
209
210        IndexArray(const Array& array,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
211            Array(array,copyop) {}
212
213        virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const IndexArray*>(obj)!=NULL; }
214
215        virtual unsigned int index(unsigned int pos) const = 0;
216
217    protected:
218
219        virtual ~IndexArray() {}
220};
221
222template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
223class TemplateIndexArray : public IndexArray, public MixinVector<T>
224{
225    public:
226
227        TemplateIndexArray() : IndexArray(ARRAYTYPE,DataSize,DataType) {}
228
229        TemplateIndexArray(const TemplateIndexArray& ta,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
230            IndexArray(ta,copyop),
231            MixinVector<T>(ta) {}
232
233        TemplateIndexArray(unsigned int no) :
234            IndexArray(ARRAYTYPE,DataSize,DataType),
235            MixinVector<T>(no) {}
236
237        TemplateIndexArray(unsigned int no,T* ptr) :
238            IndexArray(ARRAYTYPE,DataSize,DataType),
239            MixinVector<T>(ptr,ptr+no) {}
240
241        template <class InputIterator>
242        TemplateIndexArray(InputIterator first,InputIterator last) :
243            IndexArray(ARRAYTYPE,DataSize,DataType),
244            MixinVector<T>(first,last) {}       
245
246        TemplateIndexArray& operator = (const TemplateIndexArray& array)
247        {
248            if (this==&array) return *this;
249            this->assign(array.begin(),array.end());
250            return *this;
251        }
252
253        virtual Object* cloneType() const { return new TemplateIndexArray(); }
254        virtual Object* clone(const CopyOp& copyop) const { return new TemplateIndexArray(*this,copyop); }       
255
256        inline virtual void accept(ArrayVisitor& av);
257        inline virtual void accept(ConstArrayVisitor& av) const;
258
259        inline virtual void accept(unsigned int index,ValueVisitor& vv);
260        inline virtual void accept(unsigned int index,ConstValueVisitor& vv) const;
261
262        virtual int compare(unsigned int lhs,unsigned int rhs) const
263        {
264            const T& elem_lhs = (*this)[lhs];
265            const T& elem_rhs = (*this)[rhs];
266            if (elem_lhs<elem_rhs) return -1;
267            if (elem_rhs<elem_lhs) return 1;
268            return 0;
269        }
270
271        /** Frees unused space on this vector - i.e. the difference between size() and max_size() of the underlying vector.*/
272        virtual void trim()
273        {
274            MixinVector<T>( *this ).swap( *this );
275        }
276
277        virtual const GLvoid*   getDataPointer() const { if (!this->empty()) return &this->front(); else return 0; }
278        virtual unsigned int    getTotalDataSize() const { return static_cast<unsigned int>(this->size()*sizeof(T)); }
279        virtual unsigned int    getNumElements() const { return static_cast<unsigned int>(this->size()); }
280
281        virtual unsigned int    index(unsigned int pos) const { return (*this)[pos]; }
282
283        typedef T ElementDataType; // expose T
284
285    protected:
286
287        virtual ~TemplateIndexArray() {}
288};
289
290typedef TemplateIndexArray<GLbyte,Array::ByteArrayType,1,GL_BYTE>               ByteArray;
291typedef TemplateIndexArray<GLshort,Array::ShortArrayType,1,GL_SHORT>            ShortArray;
292typedef TemplateIndexArray<GLint,Array::IntArrayType,1,GL_INT>                  IntArray;
293typedef TemplateIndexArray<GLubyte,Array::UByteArrayType,1,GL_UNSIGNED_BYTE>    UByteArray;
294typedef TemplateIndexArray<GLushort,Array::UShortArrayType,1,GL_UNSIGNED_SHORT> UShortArray;
295typedef TemplateIndexArray<GLuint,Array::UIntArrayType,1,GL_UNSIGNED_INT>       UIntArray;
296
297typedef TemplateArray<GLfloat,Array::FloatArrayType,1,GL_FLOAT>                 FloatArray;
298
299typedef TemplateArray<Vec2,Array::Vec2ArrayType,2,GL_FLOAT>                     Vec2Array;
300typedef TemplateArray<Vec3,Array::Vec3ArrayType,3,GL_FLOAT>                     Vec3Array;
301typedef TemplateArray<Vec4,Array::Vec4ArrayType,4,GL_FLOAT>                     Vec4Array;
302
303typedef TemplateArray<Vec4ub,Array::Vec4ubArrayType,4,GL_UNSIGNED_BYTE>         Vec4ubArray;
304
305typedef TemplateArray<Vec2s,Array::Vec2sArrayType,2,GL_SHORT>                   Vec2sArray;
306typedef TemplateArray<Vec3s,Array::Vec3sArrayType,3,GL_SHORT>                   Vec3sArray;
307typedef TemplateArray<Vec4s,Array::Vec4sArrayType,4,GL_SHORT>                   Vec4sArray;
308
309typedef TemplateArray<Vec2b,Array::Vec2bArrayType,2,GL_BYTE>                    Vec2bArray;
310typedef TemplateArray<Vec3b,Array::Vec3bArrayType,3,GL_BYTE>                    Vec3bArray;
311typedef TemplateArray<Vec4b,Array::Vec4bArrayType,4,GL_BYTE>                    Vec4bArray;
312
313typedef TemplateArray<GLdouble,Array::DoubleArrayType,1,GL_DOUBLE>               DoubleArray;
314typedef TemplateArray<Vec2d,Array::Vec2dArrayType,2,GL_DOUBLE>                   Vec2dArray;
315typedef TemplateArray<Vec3d,Array::Vec3dArrayType,3,GL_DOUBLE>                   Vec3dArray;
316typedef TemplateArray<Vec4d,Array::Vec4dArrayType,4,GL_DOUBLE>                   Vec4dArray;
317
318typedef TemplateArray<Matrixf,Array::MatrixArrayType,16,GL_FLOAT>                MatrixfArray;
319
320
321class ArrayVisitor
322{
323    public:
324        ArrayVisitor() {}
325        virtual ~ArrayVisitor() {}
326       
327        virtual void apply(Array&) {}
328        virtual void apply(ByteArray&) {}
329        virtual void apply(ShortArray&) {}
330        virtual void apply(IntArray&) {}
331        virtual void apply(UByteArray&) {}
332        virtual void apply(UShortArray&) {}
333        virtual void apply(UIntArray&) {}
334        virtual void apply(FloatArray&) {}
335        virtual void apply(DoubleArray&) {}
336
337        virtual void apply(Vec2Array&) {}
338        virtual void apply(Vec3Array&) {}
339        virtual void apply(Vec4Array&) {}
340       
341        virtual void apply(Vec4ubArray&) {}
342
343        virtual void apply(Vec2bArray&) {}       
344        virtual void apply(Vec3bArray&) {}       
345        virtual void apply(Vec4bArray&) {}       
346
347        virtual void apply(Vec2sArray&) {}
348        virtual void apply(Vec3sArray&) {}
349        virtual void apply(Vec4sArray&) {}
350
351        virtual void apply(Vec2dArray&) {}
352        virtual void apply(Vec3dArray&) {}
353        virtual void apply(Vec4dArray&) {}
354       
355        virtual void apply(MatrixfArray&) {}
356};
357
358class ConstArrayVisitor
359{
360    public:
361        ConstArrayVisitor() {}
362        virtual ~ConstArrayVisitor() {}
363       
364        virtual void apply(const Array&) {}
365        virtual void apply(const ByteArray&) {}
366        virtual void apply(const ShortArray&) {}
367        virtual void apply(const IntArray&) {}
368        virtual void apply(const UByteArray&) {}
369        virtual void apply(const UShortArray&) {}
370        virtual void apply(const UIntArray&) {}
371        virtual void apply(const FloatArray&) {}
372        virtual void apply(const DoubleArray&) {}
373
374        virtual void apply(const Vec2Array&) {}
375        virtual void apply(const Vec3Array&) {}
376        virtual void apply(const Vec4Array&) {}
377
378        virtual void apply(const Vec4ubArray&) {}
379
380        virtual void apply(const Vec2bArray&) {}       
381        virtual void apply(const Vec3bArray&) {}       
382        virtual void apply(const Vec4bArray&) {}       
383
384        virtual void apply(const Vec2sArray&) {}
385        virtual void apply(const Vec3sArray&) {}
386        virtual void apply(const Vec4sArray&) {}
387
388        virtual void apply(const Vec2dArray&) {}
389        virtual void apply(const Vec3dArray&) {}
390        virtual void apply(const Vec4dArray&) {}
391       
392        virtual void apply(const MatrixfArray&) {}
393};
394
395
396class ValueVisitor
397{
398    public:
399        ValueVisitor() {}
400        virtual ~ValueVisitor() {}
401       
402        virtual void apply(GLbyte&) {}
403        virtual void apply(GLshort&) {}
404        virtual void apply(GLint&) {}
405        virtual void apply(GLushort&) {}
406        virtual void apply(GLubyte&) {}
407        virtual void apply(GLuint&) {}
408        virtual void apply(GLfloat&) {}
409        virtual void apply(GLdouble&) {}
410       
411       
412        virtual void apply(Vec2&) {}
413        virtual void apply(Vec3&) {}
414        virtual void apply(Vec4&) {}
415       
416        virtual void apply(Vec4ub&) {}
417
418        virtual void apply(Vec2b&) {}       
419        virtual void apply(Vec3b&) {}       
420        virtual void apply(Vec4b&) {}       
421
422        virtual void apply(Vec2s&) {}
423        virtual void apply(Vec3s&) {}
424        virtual void apply(Vec4s&) {}
425
426        virtual void apply(Vec2d&) {}
427        virtual void apply(Vec3d&) {}
428        virtual void apply(Vec4d&) {}
429       
430        virtual void apply(Matrixf&) {}
431};
432
433class ConstValueVisitor
434{
435    public:
436        ConstValueVisitor() {}
437        virtual ~ConstValueVisitor() {}
438       
439        virtual void apply(const GLbyte&) {}
440        virtual void apply(const GLshort&) {}
441        virtual void apply(const GLint&) {}
442        virtual void apply(const GLushort&) {}
443        virtual void apply(const GLubyte&) {}
444        virtual void apply(const GLuint&) {}
445        virtual void apply(const GLfloat&) {}
446        virtual void apply(const GLdouble&) {}
447
448        virtual void apply(const Vec4ub&) {}
449
450        virtual void apply(const Vec2&) {}
451        virtual void apply(const Vec3&) {}
452        virtual void apply(const Vec4&) {}
453
454        virtual void apply(const Vec2b&) {}
455        virtual void apply(const Vec3b&) {}
456        virtual void apply(const Vec4b&) {}       
457       
458        virtual void apply(const Vec2s&) {}
459        virtual void apply(const Vec3s&) {}
460        virtual void apply(const Vec4s&) {}
461       
462        virtual void apply(const Vec2d&) {}
463        virtual void apply(const Vec3d&) {}
464        virtual void apply(const Vec4d&) {}
465       
466        virtual void apply(const Matrixf&) {}
467};
468
469template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
470inline void TemplateArray<T,ARRAYTYPE,DataSize,DataType>::accept(ArrayVisitor& av) { av.apply(*this); }
471
472template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
473inline void TemplateArray<T,ARRAYTYPE,DataSize,DataType>::accept(ConstArrayVisitor& av) const { av.apply(*this); }
474
475template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
476inline void TemplateArray<T,ARRAYTYPE,DataSize,DataType>::accept(unsigned int index,ValueVisitor& vv) { vv.apply( (*this)[index] ); }
477
478template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
479inline void TemplateArray<T,ARRAYTYPE,DataSize,DataType>::accept(unsigned int index,ConstValueVisitor& vv) const {  vv.apply( (*this)[index] );}
480
481template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
482inline void TemplateIndexArray<T,ARRAYTYPE,DataSize,DataType>::accept(ArrayVisitor& av) { av.apply(*this); }
483
484template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
485inline void TemplateIndexArray<T,ARRAYTYPE,DataSize,DataType>::accept(ConstArrayVisitor& av) const { av.apply(*this); }
486
487template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
488inline void TemplateIndexArray<T,ARRAYTYPE,DataSize,DataType>::accept(unsigned int index,ValueVisitor& vv) { vv.apply( (*this)[index] ); }
489
490template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType>
491inline void TemplateIndexArray<T,ARRAYTYPE,DataSize,DataType>::accept(unsigned int index,ConstValueVisitor& vv) const {  vv.apply( (*this)[index] );}
492
493}
494
495#endif
Note: See TracBrowser for help on using the browser.