root/OpenSceneGraph/trunk/src/osg/ArrayDispatchers.cpp @ 13041

Revision 13041, 24.5 kB (checked in by robert, 3 years ago)

Ran script to remove trailing spaces and tabs

  • Property svn:eol-style set to native
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#include <osg/ArrayDispatchers>
14#include <osg/State>
15#include <osg/Drawable>
16
17#include <osg/Notify>
18#include <osg/io_utils>
19
20
21namespace osg
22{
23
24#if defined(OSG_GLES1_AVAILABLE)
25inline void GL_APIENTRY glColor4ubv(const GLubyte* c) { glColor4ub(c[0], c[1], c[2], c[3]); }
26inline void GL_APIENTRY glColor3fv(const GLfloat* c) { glColor4f(c[0], c[1], c[2], 1.0f); }
27inline void GL_APIENTRY glColor4fv(const GLfloat* c) { glColor4f(c[0], c[1], c[2], c[3]); }
28inline void GL_APIENTRY glColor3dv(const GLdouble* c) { glColor4f(c[0], c[1], c[2], 1.0f); }
29inline void GL_APIENTRY glColor4dv(const GLdouble* c) { glColor4f(c[0], c[1], c[2], c[3]); }
30
31inline void GL_APIENTRY glNormal3bv(const GLbyte* n) { const float div = 1.0f/128.0f; glNormal3f(float(n[0])*div, float(n[1])*div, float(n[3])*div); }
32inline void GL_APIENTRY glNormal3sv(const GLshort* n) { const float div = 1.0f/32768.0f; glNormal3f(float(n[0])*div, float(n[1])*div, float(n[3])*div); }
33inline void GL_APIENTRY glNormal3fv(const GLfloat* n) { glNormal3f(n[0], n[1], n[3]); }
34inline void GL_APIENTRY glNormal3dv(const GLdouble* n) { glNormal3f(n[0], n[1], n[3]); }
35#endif
36
37template<typename T>
38class TemplateAttributeDispatch : public AttributeDispatch
39{
40    public:
41
42        typedef void (GL_APIENTRY * F) (const T*);
43
44        TemplateAttributeDispatch(F functionPtr, unsigned int stride):
45            _functionPtr(functionPtr), _stride(stride), _array(0) {}
46
47        virtual void assign(const GLvoid* array, const IndexArray*)
48        {
49            _array = reinterpret_cast<const T*>(array);
50        }
51
52        virtual void operator () (unsigned int pos)
53        {
54            _functionPtr(&(_array[pos*_stride]));
55        }
56
57        F               _functionPtr;
58        unsigned int    _stride;
59        const T*        _array;
60};
61
62template<typename T>
63class TemplateAttributeWithIndicesDispatch : public AttributeDispatch
64{
65    public:
66
67        typedef void (GL_APIENTRY * F) (const T*);
68
69        TemplateAttributeWithIndicesDispatch(F functionPtr, unsigned int stride):
70            _functionPtr(functionPtr), _stride(stride), _array(0), _indices(0) {}
71
72        virtual void assign(const GLvoid* array, const IndexArray* indices)
73        {
74            _array = reinterpret_cast<const T*>(array);
75            _indices = indices;
76        }
77
78        virtual void operator () (unsigned int pos)
79        {
80            _functionPtr(&(_array[_indices->index(pos) * _stride]));
81        }
82
83        F                       _functionPtr;
84        unsigned int            _stride;
85        const T*                _array;
86        const IndexArray*       _indices;
87};
88
89template<typename T>
90class TemplateBeginEndAttributeDispatch : public AttributeDispatch
91{
92    public:
93
94        typedef void (GLBeginEndAdapter::*F) (const T*);
95
96        TemplateBeginEndAttributeDispatch(GLBeginEndAdapter* glBeginEndAdapter, F functionPtr, unsigned int stride):
97            _glBeginEndAdapter(glBeginEndAdapter),
98            _functionPtr(functionPtr), _stride(stride), _array(0) {}
99
100        virtual void assign(const GLvoid* array, const IndexArray*)
101        {
102            _array = reinterpret_cast<const T*>(array);
103        }
104
105        virtual void operator () (unsigned int pos)
106        {
107            (_glBeginEndAdapter->*_functionPtr)(&(_array[pos*_stride]));
108        }
109
110        GLBeginEndAdapter*      _glBeginEndAdapter;
111        F                       _functionPtr;
112        unsigned int            _stride;
113        const T*                _array;
114};
115
116template<typename T>
117class TemplateBeginEndAttributeWithIndicesDispatch : public AttributeDispatch
118{
119    public:
120
121        typedef void (GLBeginEndAdapter::*F) (const T*);
122
123        TemplateBeginEndAttributeWithIndicesDispatch(GLBeginEndAdapter* glBeginEndAdapter, F functionPtr, unsigned int stride):
124            _glBeginEndAdapter(glBeginEndAdapter),
125            _functionPtr(functionPtr), _stride(stride), _array(0), _indices(0) {}
126
127        virtual void assign(const GLvoid* array, const IndexArray* indices)
128        {
129            _array = reinterpret_cast<const T*>(array);
130            _indices = indices;
131        }
132
133        virtual void operator () (unsigned int pos)
134        {
135            (_glBeginEndAdapter->*_functionPtr)(&(_array[_indices->index(pos) * _stride]));
136        }
137
138        GLBeginEndAdapter*      _glBeginEndAdapter;
139        F                       _functionPtr;
140        unsigned int            _stride;
141        const T*                _array;
142        const IndexArray*       _indices;
143};
144
145
146template<typename I, typename T>
147class TemplateTargetAttributeDispatch : public AttributeDispatch
148{
149    public:
150
151        typedef void (GL_APIENTRY * F) (I, const T*);
152
153        TemplateTargetAttributeDispatch(I target, F functionPtr, unsigned int stride):
154            _functionPtr(functionPtr), _target(target), _stride(stride), _array(0) {}
155
156        virtual void assign(const GLvoid* array, const IndexArray*)
157        {
158            _array = reinterpret_cast<const T*>(array);
159        }
160
161        virtual void operator () (unsigned int pos)
162        {
163            _functionPtr(_target, &(_array[pos * _stride]));
164        }
165
166        F                       _functionPtr;
167        I                       _target;
168        unsigned int            _stride;
169        const T*                _array;
170};
171
172template<typename I, typename T>
173class TemplateTargetAttributeWithIndicesDispatch : public AttributeDispatch
174{
175    public:
176
177        typedef void (GL_APIENTRY * F) (I, const T*);
178
179        TemplateTargetAttributeWithIndicesDispatch(I target, F functionPtr, unsigned int stride):
180            _functionPtr(functionPtr), _target(target), _stride(stride), _array(0), _indices(0) {}
181
182        virtual void assign(const GLvoid* array, const IndexArray* indices)
183        {
184            _array = reinterpret_cast<const T*>(array);
185            _indices = indices;
186        }
187
188        virtual void operator () (unsigned int pos)
189        {
190            _functionPtr(_target, &(_array[_indices->index(pos) * _stride]));
191        }
192
193        F                       _functionPtr;
194        I                       _target;
195        unsigned int            _stride;
196        const T*                _array;
197        const IndexArray*       _indices;
198};
199
200
201template<typename I, typename T>
202class TemplateBeginEndTargetAttributeDispatch : public AttributeDispatch
203{
204    public:
205
206        typedef void (GLBeginEndAdapter::*F) (I, const T*);
207
208        TemplateBeginEndTargetAttributeDispatch(GLBeginEndAdapter* glBeginEndAdapter, I target, F functionPtr, unsigned int stride):
209            _glBeginEndAdapter(glBeginEndAdapter),
210            _functionPtr(functionPtr), _target(target), _stride(stride), _array(0) {}
211
212        virtual void assign(const GLvoid* array, const IndexArray*)
213        {
214            _array = reinterpret_cast<const T*>(array);
215        }
216
217        virtual void operator () (unsigned int pos)
218        {
219            (_glBeginEndAdapter->*_functionPtr)(_target, &(_array[pos * _stride]));
220        }
221
222        GLBeginEndAdapter*      _glBeginEndAdapter;
223        F                       _functionPtr;
224        I                       _target;
225        unsigned int            _stride;
226        const T*                _array;
227};
228
229template<typename I, typename T>
230class TemplateBeginEndTargetAttributeWithIndicesDispatch : public AttributeDispatch
231{
232    public:
233
234        typedef void (GLBeginEndAdapter::*F) (I, const T*);
235
236        TemplateBeginEndTargetAttributeWithIndicesDispatch(GLBeginEndAdapter* glBeginEndAdapter, I target, F functionPtr, unsigned int stride):
237            _glBeginEndAdapter(glBeginEndAdapter),
238            _functionPtr(functionPtr), _target(target), _stride(stride), _array(0), _indices(0) {}
239
240        virtual void assign(const GLvoid* array, const IndexArray* indices)
241        {
242            _array = reinterpret_cast<const T*>(array);
243            _indices = indices;
244        }
245
246        virtual void operator () (unsigned int pos)
247        {
248            (_glBeginEndAdapter->*_functionPtr)(_target, &(_array[_indices->index(pos) * _stride]));
249        }
250
251        GLBeginEndAdapter*      _glBeginEndAdapter;
252        F                       _functionPtr;
253        I                       _target;
254        unsigned int            _stride;
255        const T*                _array;
256        const IndexArray*       _indices;
257};
258
259class AttributeDispatchMap
260{
261public:
262
263    AttributeDispatchMap(GLBeginEndAdapter* glBeginEndAdapter):
264        _glBeginEndAdapter(glBeginEndAdapter) {}
265
266    template<typename T>
267    void assign(Array::Type type, void (GL_APIENTRY *functionPtr) (const T*), unsigned int stride)
268    {
269        if ((unsigned int)type >= _attributeDispatchList.size()) _attributeDispatchList.resize(type+1);
270        _attributeDispatchList[type] = functionPtr ? new TemplateAttributeDispatch<T>(functionPtr, stride) : 0;
271
272        if ((unsigned int)type >= _attributeDispatchWithIndicesList.size()) _attributeDispatchWithIndicesList.resize(type+1);
273        _attributeDispatchWithIndicesList[type] = functionPtr ? new TemplateAttributeWithIndicesDispatch<T>(functionPtr, stride) : 0;
274    }
275
276    template<typename I, typename T>
277    void targetAssign(I target, Array::Type type, void (GL_APIENTRY *functionPtr) (I, const T*), unsigned int stride)
278    {
279        if ((unsigned int)type >= _attributeDispatchList.size()) _attributeDispatchList.resize(type+1);
280        _attributeDispatchList[type] = functionPtr ? new TemplateTargetAttributeDispatch<I,T>(target, functionPtr, stride) : 0;
281
282        if ((unsigned int)type >= _attributeDispatchWithIndicesList.size()) _attributeDispatchWithIndicesList.resize(type+1);
283        _attributeDispatchWithIndicesList[type] = functionPtr ? new TemplateTargetAttributeWithIndicesDispatch<I,T>(target, functionPtr, stride) : 0;
284    }
285
286    template<typename T>
287    void assignGLBeginEnd(Array::Type type, void (GLBeginEndAdapter::*functionPtr) (const T*), unsigned int stride)
288    {
289        if ((unsigned int)type >= _glBeginEndAttributeDispatchList.size()) _glBeginEndAttributeDispatchList.resize(type+1);
290        _glBeginEndAttributeDispatchList[type] = functionPtr ? new TemplateBeginEndAttributeDispatch<T>(_glBeginEndAdapter, functionPtr, stride) : 0;
291
292        if ((unsigned int)type >= _glBeginEndAttributeDispatchWithIndicesList.size()) _glBeginEndAttributeDispatchWithIndicesList.resize(type+1);
293        _glBeginEndAttributeDispatchWithIndicesList[type] = functionPtr ? new TemplateBeginEndAttributeWithIndicesDispatch<T>(_glBeginEndAdapter, functionPtr, stride) : 0;
294    }
295
296    template<typename I, typename T>
297    void targetGLBeginEndAssign(I target, Array::Type type, void (GLBeginEndAdapter::*functionPtr) (I, const T*), unsigned int stride)
298    {
299        if ((unsigned int)type >= _glBeginEndAttributeDispatchList.size()) _glBeginEndAttributeDispatchList.resize(type+1);
300        _glBeginEndAttributeDispatchList[type] = functionPtr ? new TemplateBeginEndTargetAttributeDispatch<I,T>(_glBeginEndAdapter, target, functionPtr, stride) : 0;
301
302        if ((unsigned int)type >= _glBeginEndAttributeDispatchWithIndicesList.size()) _glBeginEndAttributeDispatchWithIndicesList.resize(type+1);
303        _glBeginEndAttributeDispatchWithIndicesList[type] = functionPtr ? new TemplateBeginEndTargetAttributeWithIndicesDispatch<I,T>(_glBeginEndAdapter, target, functionPtr, stride) : 0;
304    }
305
306
307    AttributeDispatch* dispatcher(bool useGLBeginEndAdapter, const Array* array, const IndexArray* indices)
308    {
309        // OSG_NOTICE<<"dispatcher("<<useGLBeginEndAdapter<<", "<<array<<", "<<indices<<")"<<std::endl;
310
311        if (!array) return 0;
312
313        Array::Type type = array->getType();
314        AttributeDispatch* dispatcher = 0;
315
316        // OSG_NOTICE<<"    array->getType()="<<type<<std::endl;
317        // OSG_NOTICE<<"    _glBeginEndAttributeDispatchList.size()="<<_glBeginEndAttributeDispatchList.size()<<std::endl;
318        // OSG_NOTICE<<"    _glBeginEndAttributeDispatchWithIndicesList.size()="<<_glBeginEndAttributeDispatchWithIndicesList.size()<<std::endl;
319        // OSG_NOTICE<<"    _attributeDispatchIndicesList.size()="<<_attributeDispatchList.size()<<std::endl;
320        // OSG_NOTICE<<"    _attributeDispatchWithIndicesList.size()="<<_attributeDispatchWithIndicesList.size()<<std::endl;
321
322        if (useGLBeginEndAdapter)
323        {
324            if (indices)
325            {
326                if ((unsigned int)type<_glBeginEndAttributeDispatchWithIndicesList.size())
327                {
328                    dispatcher = _glBeginEndAttributeDispatchWithIndicesList[array->getType()].get();
329                }
330            }
331            else if ((unsigned int)type<_glBeginEndAttributeDispatchList.size())
332            {
333                dispatcher = _glBeginEndAttributeDispatchList[array->getType()].get();
334            }
335        }
336        else
337        {
338            if (indices)
339            {
340                if ((unsigned int)type<_attributeDispatchWithIndicesList.size())
341                {
342                    dispatcher = _attributeDispatchWithIndicesList[array->getType()].get();
343                }
344            }
345            else if ((unsigned int)type<_attributeDispatchList.size())
346            {
347                dispatcher = _attributeDispatchList[array->getType()].get();
348            }
349        }
350
351        if (dispatcher)
352        {
353            // OSG_NOTICE<<"   returning dispatcher="<<dispatcher<<std::endl;
354            dispatcher->assign(array->getDataPointer(), indices);
355            return dispatcher;
356        }
357        else
358        {
359            // OSG_NOTICE<<"   no dispatcher found"<<std::endl;
360            return 0;
361        }
362    }
363
364    typedef std::vector< ref_ptr<AttributeDispatch> >  AttributeDispatchList;
365    GLBeginEndAdapter*                  _glBeginEndAdapter;
366    AttributeDispatchList               _attributeDispatchList;
367    AttributeDispatchList               _attributeDispatchWithIndicesList;
368    AttributeDispatchList               _glBeginEndAttributeDispatchList;
369    AttributeDispatchList               _glBeginEndAttributeDispatchWithIndicesList;
370};
371
372ArrayDispatchers::ArrayDispatchers():
373    _initialized(false),
374    _state(0),
375    _glBeginEndAdapter(0),
376    _vertexDispatchers(0),
377    _normalDispatchers(0),
378    _colorDispatchers(0),
379    _secondaryColorDispatchers(0),
380    _fogCoordDispatchers(0),
381    _useVertexAttribAlias(false),
382    _useGLBeginEndAdapter(false)
383{
384
385}
386
387ArrayDispatchers::~ArrayDispatchers()
388{
389    delete _vertexDispatchers;
390    delete _normalDispatchers;
391    delete _colorDispatchers;
392    delete _secondaryColorDispatchers;
393    delete _fogCoordDispatchers;
394
395    for(AttributeDispatchMapList::iterator itr = _texCoordDispatchers.begin();
396        itr != _texCoordDispatchers.end();
397        ++itr)
398    {
399        delete *itr;
400    }
401
402    for(AttributeDispatchMapList::iterator itr = _vertexAttribDispatchers.begin();
403        itr != _vertexAttribDispatchers.end();
404        ++itr)
405    {
406        delete *itr;
407    }
408}
409
410void ArrayDispatchers::setState(osg::State* state)
411{
412    _state = state;
413    _glBeginEndAdapter = &(state->getGLBeginEndAdapter());
414}
415
416void ArrayDispatchers::init()
417{
418    if (_initialized) return;
419
420    _initialized = true;
421
422    _vertexDispatchers = new AttributeDispatchMap(&(_state->getGLBeginEndAdapter()));
423    _normalDispatchers = new AttributeDispatchMap(&(_state->getGLBeginEndAdapter()));
424    _colorDispatchers = new AttributeDispatchMap(&(_state->getGLBeginEndAdapter()));
425    _secondaryColorDispatchers  = new AttributeDispatchMap(&(_state->getGLBeginEndAdapter()));
426    _fogCoordDispatchers = new AttributeDispatchMap(&(_state->getGLBeginEndAdapter()));
427
428    _glBeginEndAdapter = &(_state->getGLBeginEndAdapter());
429    _useGLBeginEndAdapter = false;
430
431    _vertexDispatchers->assignGLBeginEnd<GLfloat>(Array::Vec3ArrayType, &GLBeginEndAdapter::Vertex3fv, 3);
432    _vertexDispatchers->assignGLBeginEnd<GLdouble>(Array::Vec3dArrayType, &GLBeginEndAdapter::Vertex3dv, 3);
433    _normalDispatchers->assignGLBeginEnd<GLfloat>(Array::Vec3ArrayType, &GLBeginEndAdapter::Normal3fv, 3);
434    _colorDispatchers->assignGLBeginEnd<GLubyte>(Array::Vec4ubArrayType, &GLBeginEndAdapter::Color4ubv, 4);
435    _colorDispatchers->assignGLBeginEnd<GLfloat>(Array::Vec4ArrayType, &GLBeginEndAdapter::Color4fv, 4);
436
437#ifdef OSG_GL_VERTEX_FUNCS_AVAILABLE
438    Drawable::Extensions* extensions = Drawable::getExtensions(_state->getContextID(),true);
439
440    #ifndef OSG_GLES1_AVAILABLE
441        _vertexDispatchers->assign<GLfloat>(Array::Vec2ArrayType, glVertex2fv, 2);
442        _vertexDispatchers->assign<GLfloat>(Array::Vec3ArrayType, glVertex3fv, 3);
443        _vertexDispatchers->assign<GLdouble>(Array::Vec2dArrayType, glVertex2dv, 2);
444        _vertexDispatchers->assign<GLdouble>(Array::Vec3dArrayType, glVertex3dv, 3);
445    #endif
446
447    _normalDispatchers->assign<GLbyte>(Array::Vec3bArrayType, glNormal3bv, 3);
448    _normalDispatchers->assign<GLshort>(Array::Vec3sArrayType, glNormal3sv, 3);
449    _normalDispatchers->assign<GLfloat>(Array::Vec3ArrayType, glNormal3fv, 3);
450    _normalDispatchers->assign<GLdouble>(Array::Vec3dArrayType, glNormal3dv, 3);
451
452    _colorDispatchers->assign<GLubyte>(Array::Vec4ubArrayType, glColor4ubv, 4);
453    _colorDispatchers->assign<GLfloat>(Array::Vec3ArrayType, glColor3fv, 3);
454    _colorDispatchers->assign<GLfloat>(Array::Vec4ArrayType, glColor4fv, 4);
455    _colorDispatchers->assign<GLdouble>(Array::Vec3dArrayType, glColor3dv, 3);
456    _colorDispatchers->assign<GLdouble>(Array::Vec4dArrayType, glColor4dv, 4);
457
458    _secondaryColorDispatchers->assign<GLfloat>(Array::Vec3ArrayType, extensions->_glSecondaryColor3fv, 3);
459
460    _fogCoordDispatchers->assign<GLfloat>(Array::FloatArrayType, extensions->_glFogCoordfv, 1);
461#endif
462
463    // pre allocate.
464    _activeDispatchList.resize(5);
465}
466
467AttributeDispatch* ArrayDispatchers::vertexDispatcher(Array* array, IndexArray* indices)
468{
469    return _useVertexAttribAlias ?
470           vertexAttribDispatcher(_state->getVertexAlias()._location, array, indices) :
471           _vertexDispatchers->dispatcher(_useGLBeginEndAdapter, array, indices);
472}
473
474AttributeDispatch* ArrayDispatchers::normalDispatcher(Array* array, IndexArray* indices)
475{
476    return _useVertexAttribAlias ?
477           vertexAttribDispatcher(_state->getNormalAlias()._location, array, indices) :
478           _normalDispatchers->dispatcher(_useGLBeginEndAdapter, array, indices);
479}
480
481AttributeDispatch* ArrayDispatchers::colorDispatcher(Array* array, IndexArray* indices)
482{
483    return _useVertexAttribAlias ?
484           vertexAttribDispatcher(_state->getColorAlias()._location, array, indices) :
485           _colorDispatchers->dispatcher(_useGLBeginEndAdapter, array, indices);
486}
487
488AttributeDispatch* ArrayDispatchers::secondaryColorDispatcher(Array* array, IndexArray* indices)
489{
490    return _useVertexAttribAlias ?
491           vertexAttribDispatcher(_state->getSecondaryColorAlias()._location, array, indices) :
492           _secondaryColorDispatchers->dispatcher(_useGLBeginEndAdapter, array, indices);
493}
494
495AttributeDispatch* ArrayDispatchers::fogCoordDispatcher(Array* array, IndexArray* indices)
496{
497    return _useVertexAttribAlias ?
498           vertexAttribDispatcher(_state->getFogCoordAlias()._location, array, indices) :
499           _fogCoordDispatchers->dispatcher(_useGLBeginEndAdapter, array, indices);
500}
501
502AttributeDispatch* ArrayDispatchers::texCoordDispatcher(unsigned int unit, Array* array, IndexArray* indices)
503{
504    if (_useVertexAttribAlias) return vertexAttribDispatcher(_state->getTexCoordAliasList()[unit]._location, array, indices);
505
506    if (unit>=_texCoordDispatchers.size()) assignTexCoordDispatchers(unit);
507    return _texCoordDispatchers[unit]->dispatcher(_useGLBeginEndAdapter, array, indices);
508}
509
510AttributeDispatch* ArrayDispatchers::vertexAttribDispatcher(unsigned int unit, Array* array, IndexArray* indices)
511{
512    if (unit>=_vertexAttribDispatchers.size()) assignVertexAttribDispatchers(unit);
513    return _vertexAttribDispatchers[unit]->dispatcher(_useGLBeginEndAdapter, array, indices);
514}
515
516void ArrayDispatchers::assignTexCoordDispatchers(unsigned int unit)
517{
518    #if defined(OSG_GL_VERTEX_FUNCS_AVAILABLE) && !defined(OSG_GLES1_AVAILABLE)
519    Drawable::Extensions* extensions = Drawable::getExtensions(_state->getContextID(),true);
520    #endif
521
522    for(unsigned int i=_texCoordDispatchers.size(); i<=unit; ++i)
523    {
524        _texCoordDispatchers.push_back(new AttributeDispatchMap(_glBeginEndAdapter));
525        AttributeDispatchMap& texCoordDispatcher = *_texCoordDispatchers[i];
526        if (i==0)
527        {
528            #if defined(OSG_GL_VERTEX_FUNCS_AVAILABLE) && !defined(OSG_GLES1_AVAILABLE)
529            texCoordDispatcher.assign<GLfloat>(Array::FloatArrayType, glTexCoord1fv, 1);
530            texCoordDispatcher.assign<GLfloat>(Array::Vec2ArrayType, glTexCoord2fv, 2);
531            texCoordDispatcher.assign<GLfloat>(Array::Vec3ArrayType, glTexCoord3fv, 3);
532            texCoordDispatcher.assign<GLfloat>(Array::Vec4ArrayType, glTexCoord4fv, 4);
533            #endif
534            texCoordDispatcher.assignGLBeginEnd<GLfloat>(Array::FloatArrayType, &GLBeginEndAdapter::TexCoord1fv, 1);
535            texCoordDispatcher.assignGLBeginEnd<GLfloat>(Array::Vec2ArrayType, &GLBeginEndAdapter::TexCoord2fv, 2);
536            texCoordDispatcher.assignGLBeginEnd<GLfloat>(Array::Vec3ArrayType, &GLBeginEndAdapter::TexCoord3fv, 3);
537            texCoordDispatcher.assignGLBeginEnd<GLfloat>(Array::Vec4ArrayType, &GLBeginEndAdapter::TexCoord4fv, 4);
538        }
539        else
540        {
541            #if defined(OSG_GL_VERTEX_FUNCS_AVAILABLE) && !defined(OSG_GLES1_AVAILABLE)
542            texCoordDispatcher.targetAssign<GLenum, GLfloat>((GLenum)(GL_TEXTURE0+i), Array::FloatArrayType, extensions->_glMultiTexCoord1fv, 1);
543            texCoordDispatcher.targetAssign<GLenum, GLfloat>((GLenum)(GL_TEXTURE0+i), Array::Vec2ArrayType, extensions->_glMultiTexCoord2fv, 2);
544            texCoordDispatcher.targetAssign<GLenum, GLfloat>((GLenum)(GL_TEXTURE0+i), Array::Vec3ArrayType, extensions->_glMultiTexCoord3fv, 3);
545            texCoordDispatcher.targetAssign<GLenum, GLfloat>((GLenum)(GL_TEXTURE0+i), Array::Vec4ArrayType, extensions->_glMultiTexCoord4fv, 4);
546            #endif
547            texCoordDispatcher.targetGLBeginEndAssign<GLenum, GLfloat>((GLenum)(GL_TEXTURE0+i), Array::FloatArrayType, &GLBeginEndAdapter::MultiTexCoord1fv, 1);
548            texCoordDispatcher.targetGLBeginEndAssign<GLenum, GLfloat>((GLenum)(GL_TEXTURE0+i), Array::Vec2ArrayType, &GLBeginEndAdapter::MultiTexCoord2fv, 2);
549            texCoordDispatcher.targetGLBeginEndAssign<GLenum, GLfloat>((GLenum)(GL_TEXTURE0+i), Array::Vec3ArrayType, &GLBeginEndAdapter::MultiTexCoord3fv, 3);
550            texCoordDispatcher.targetGLBeginEndAssign<GLenum, GLfloat>((GLenum)(GL_TEXTURE0+i), Array::Vec4ArrayType, &GLBeginEndAdapter::MultiTexCoord4fv, 4);
551        }
552    }
553
554}
555
556void ArrayDispatchers::assignVertexAttribDispatchers(unsigned int unit)
557{
558    Drawable::Extensions* extensions = Drawable::getExtensions(_state->getContextID(),true);
559
560    for(unsigned int i=_vertexAttribDispatchers.size(); i<=unit; ++i)
561    {
562        _vertexAttribDispatchers.push_back(new AttributeDispatchMap(_glBeginEndAdapter));
563        AttributeDispatchMap& vertexAttribDispatcher = *_vertexAttribDispatchers[i];
564        vertexAttribDispatcher.targetAssign<GLuint, GLfloat>(i, Array::FloatArrayType, extensions->_glVertexAttrib1fv, 1);
565        vertexAttribDispatcher.targetAssign<GLuint, GLfloat>(i, Array::Vec2ArrayType, extensions->_glVertexAttrib2fv, 2);
566        vertexAttribDispatcher.targetAssign<GLuint, GLfloat>(i, Array::Vec3ArrayType, extensions->_glVertexAttrib3fv, 3);
567        vertexAttribDispatcher.targetAssign<GLuint, GLfloat>(i, Array::Vec4ArrayType, extensions->_glVertexAttrib4fv, 4);
568        vertexAttribDispatcher.targetGLBeginEndAssign<GLenum, GLfloat>(i, Array::FloatArrayType, &GLBeginEndAdapter::VertexAttrib1fv, 1);
569        vertexAttribDispatcher.targetGLBeginEndAssign<GLenum, GLfloat>(i, Array::Vec2ArrayType, &GLBeginEndAdapter::VertexAttrib2fv, 2);
570        vertexAttribDispatcher.targetGLBeginEndAssign<GLenum, GLfloat>(i, Array::Vec3ArrayType, &GLBeginEndAdapter::VertexAttrib3fv, 3);
571        vertexAttribDispatcher.targetGLBeginEndAssign<GLenum, GLfloat>(i, Array::Vec4ArrayType, &GLBeginEndAdapter::VertexAttrib4fv, 4);
572    }
573}
574
575void ArrayDispatchers::reset()
576{
577    if (!_initialized) init();
578
579    _useVertexAttribAlias = false;
580    _useGLBeginEndAdapter = false;
581
582    for(ActiveDispatchList::iterator itr = _activeDispatchList.begin();
583        itr != _activeDispatchList.end();
584        ++itr)
585    {
586        (*itr).clear();
587    }
588}
589
590}
Note: See TracBrowser for help on using the browser.