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

Revision 10752, 24.5 kB (checked in by robert, 4 years ago)

Moved the GLBeginEndAdapter support out of the blocks of the "#if defined(OSG_GL_VERTEX_FUNCS_AVAILABLE) && !defined(OSG_GLES1_AVAILABLE)" guarded blocks.

Fixed the number of components being passed as GLBeginEndAdatper::TexCoord?*fv.

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 APIENTRY glColor4ubv(const GLubyte* c) { glColor4ub(c[0], c[1], c[2], c[3]); }
26inline void APIENTRY glColor3fv(const GLfloat* c) { glColor4f(c[0], c[1], c[2], 1.0f); }
27inline void APIENTRY glColor4fv(const GLfloat* c) { glColor4f(c[0], c[1], c[2], c[3]); }
28inline void APIENTRY glColor3dv(const GLdouble* c) { glColor4f(c[0], c[1], c[2], 1.0f); }
29inline void APIENTRY glColor4dv(const GLdouble* c) { glColor4f(c[0], c[1], c[2], c[3]); }
30
31inline void 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 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 APIENTRY glNormal3fv(const GLfloat* n) { glNormal3f(n[0], n[1], n[3]); }
34inline void 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 (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 (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 (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        GLBeginEndAdapter*      _glBeginEndAdapter;
167        F                       _functionPtr;
168        I                       _target;
169        unsigned int            _stride;
170        const T*                _array;
171};
172
173template<typename I, typename T>
174class TemplateTargetAttributeWithIndicesDispatch : public AttributeDispatch
175{
176    public:
177
178        typedef void (APIENTRY * F) (I, const T*);
179
180        TemplateTargetAttributeWithIndicesDispatch(I target, F functionPtr, unsigned int stride):
181            _functionPtr(functionPtr), _target(target), _stride(stride), _array(0), _indices(0) {}
182
183        virtual void assign(const GLvoid* array, const IndexArray* indices)
184        {
185            _array = reinterpret_cast<const T*>(array);
186            _indices = indices;
187        }
188
189        virtual void operator () (unsigned int pos)
190        {
191            _functionPtr(_target, &(_array[_indices->index(pos) * _stride]));
192        }
193
194        F                       _functionPtr;
195        I                       _target;
196        unsigned int            _stride;
197        const T*                _array;
198        const IndexArray*       _indices;
199};
200
201
202template<typename I, typename T>
203class TemplateBeginEndTargetAttributeDispatch : public AttributeDispatch
204{
205    public:
206
207        typedef void (GLBeginEndAdapter::*F) (I, const T*);
208
209        TemplateBeginEndTargetAttributeDispatch(GLBeginEndAdapter* glBeginEndAdapter, I target, F functionPtr, unsigned int stride):
210            _glBeginEndAdapter(glBeginEndAdapter),
211            _functionPtr(functionPtr), _target(target), _stride(stride), _array(0) {}
212
213        virtual void assign(const GLvoid* array, const IndexArray*)
214        {
215            _array = reinterpret_cast<const T*>(array);
216        }
217
218        virtual void operator () (unsigned int pos)
219        {
220            (_glBeginEndAdapter->*_functionPtr)(_target, &(_array[pos * _stride]));
221        }
222
223        GLBeginEndAdapter*      _glBeginEndAdapter;
224        F                       _functionPtr;
225        I                       _target;
226        unsigned int            _stride;
227        const T*                _array;
228};
229
230template<typename I, typename T>
231class TemplateBeginEndTargetAttributeWithIndicesDispatch : public AttributeDispatch
232{
233    public:
234
235        typedef void (GLBeginEndAdapter::*F) (I, const T*);
236
237        TemplateBeginEndTargetAttributeWithIndicesDispatch(GLBeginEndAdapter* glBeginEndAdapter, I target, F functionPtr, unsigned int stride):
238            _glBeginEndAdapter(glBeginEndAdapter),
239            _functionPtr(functionPtr), _target(target), _stride(stride), _array(0), _indices(0) {}
240
241        virtual void assign(const GLvoid* array, const IndexArray* indices)
242        {
243            _array = reinterpret_cast<const T*>(array);
244            _indices = indices;
245        }
246
247        virtual void operator () (unsigned int pos)
248        {
249            (_glBeginEndAdapter->*_functionPtr)(_target, &(_array[_indices->index(pos) * _stride]));
250        }
251
252        GLBeginEndAdapter*      _glBeginEndAdapter;
253        F                       _functionPtr;
254        I                       _target;
255        unsigned int            _stride;
256        const T*                _array;
257        const IndexArray*       _indices;
258};
259
260class AttributeDispatchMap
261{
262public:
263
264    AttributeDispatchMap(GLBeginEndAdapter* glBeginEndAdapter):
265        _glBeginEndAdapter(glBeginEndAdapter) {}
266
267    template<typename T>
268    void assign(Array::Type type, void (APIENTRY *functionPtr) (const T*), unsigned int stride)
269    {
270        if ((unsigned int)type >= _attributeDispatchList.size()) _attributeDispatchList.resize(type+1);
271        _attributeDispatchList[type] = functionPtr ? new TemplateAttributeDispatch<T>(functionPtr, stride) : 0;
272
273        if ((unsigned int)type >= _attributeDispatchWithIndicesList.size()) _attributeDispatchWithIndicesList.resize(type+1);
274        _attributeDispatchWithIndicesList[type] = functionPtr ? new TemplateAttributeWithIndicesDispatch<T>(functionPtr, stride) : 0;
275    }
276
277    template<typename I, typename T>
278    void targetAssign(I target, Array::Type type, void (APIENTRY *functionPtr) (I, const T*), unsigned int stride)
279    {
280        if ((unsigned int)type >= _attributeDispatchList.size()) _attributeDispatchList.resize(type+1);
281        _attributeDispatchList[type] = functionPtr ? new TemplateTargetAttributeDispatch<I,T>(target, functionPtr, stride) : 0;
282
283        if ((unsigned int)type >= _attributeDispatchWithIndicesList.size()) _attributeDispatchWithIndicesList.resize(type+1);
284        _attributeDispatchWithIndicesList[type] = functionPtr ? new TemplateTargetAttributeWithIndicesDispatch<I,T>(target, functionPtr, stride) : 0;
285    }
286
287    template<typename T>
288    void assignGLBeginEnd(Array::Type type, void (GLBeginEndAdapter::*functionPtr) (const T*), unsigned int stride)
289    {
290        if ((unsigned int)type >= _glBeginEndAttributeDispatchList.size()) _glBeginEndAttributeDispatchList.resize(type+1);
291        _glBeginEndAttributeDispatchList[type] = functionPtr ? new TemplateBeginEndAttributeDispatch<T>(_glBeginEndAdapter, functionPtr, stride) : 0;
292
293        if ((unsigned int)type >= _glBeginEndAttributeDispatchWithIndicesList.size()) _glBeginEndAttributeDispatchWithIndicesList.resize(type+1);
294        _glBeginEndAttributeDispatchWithIndicesList[type] = functionPtr ? new TemplateBeginEndAttributeWithIndicesDispatch<T>(_glBeginEndAdapter, functionPtr, stride) : 0;
295    }
296
297    template<typename I, typename T>
298    void targetGLBeginEndAssign(I target, Array::Type type, void (GLBeginEndAdapter::*functionPtr) (I, const T*), unsigned int stride)
299    {
300        if ((unsigned int)type >= _glBeginEndAttributeDispatchList.size()) _glBeginEndAttributeDispatchList.resize(type+1);
301        _glBeginEndAttributeDispatchList[type] = functionPtr ? new TemplateBeginEndTargetAttributeDispatch<I,T>(_glBeginEndAdapter, target, functionPtr, stride) : 0;
302
303        if ((unsigned int)type >= _glBeginEndAttributeDispatchWithIndicesList.size()) _glBeginEndAttributeDispatchWithIndicesList.resize(type+1);
304        _glBeginEndAttributeDispatchWithIndicesList[type] = functionPtr ? new TemplateBeginEndTargetAttributeWithIndicesDispatch<I,T>(_glBeginEndAdapter, target, functionPtr, stride) : 0;
305    }
306
307
308    AttributeDispatch* dispatcher(bool useGLBeginEndAdapter, const Array* array, const IndexArray* indices)
309    {
310        // osg::notify(osg::NOTICE)<<"dispatcher("<<useGLBeginEndAdapter<<", "<<array<<", "<<indices<<")"<<std::endl;
311
312        if (!array) return 0;
313
314        Array::Type type = array->getType();
315        AttributeDispatch* dispatcher = 0;
316
317        // osg::notify(osg::NOTICE)<<"    array->getType()="<<type<<std::endl;
318        // osg::notify(osg::NOTICE)<<"    _glBeginEndAttributeDispatchList.size()="<<_glBeginEndAttributeDispatchList.size()<<std::endl;
319        // osg::notify(osg::NOTICE)<<"    _glBeginEndAttributeDispatchWithIndicesList.size()="<<_glBeginEndAttributeDispatchWithIndicesList.size()<<std::endl;
320        // osg::notify(osg::NOTICE)<<"    _attributeDispatchIndicesList.size()="<<_attributeDispatchList.size()<<std::endl;
321        // osg::notify(osg::NOTICE)<<"    _attributeDispatchWithIndicesList.size()="<<_attributeDispatchWithIndicesList.size()<<std::endl;
322
323        if (useGLBeginEndAdapter)
324        {
325            if (indices)
326            {
327                if ((unsigned int)type<_glBeginEndAttributeDispatchWithIndicesList.size())
328                {
329                    dispatcher = _glBeginEndAttributeDispatchWithIndicesList[array->getType()].get();
330                }
331            }
332            else if ((unsigned int)type<_glBeginEndAttributeDispatchList.size())
333            {
334                dispatcher = _glBeginEndAttributeDispatchList[array->getType()].get();
335            }
336        }
337        else
338        {
339            if (indices)
340            {
341                if ((unsigned int)type<_attributeDispatchWithIndicesList.size())
342                {
343                    dispatcher = _attributeDispatchWithIndicesList[array->getType()].get();
344                }
345            }
346            else if ((unsigned int)type<_attributeDispatchList.size())
347            {
348                dispatcher = _attributeDispatchList[array->getType()].get();
349            }
350        }
351
352        if (dispatcher)
353        {
354            // osg::notify(osg::NOTICE)<<"   returning dispatcher="<<dispatcher<<std::endl;
355            dispatcher->assign(array->getDataPointer(), indices);
356            return dispatcher;
357        }
358        else
359        {
360            // osg::notify(osg::NOTICE)<<"   no dispatcher found"<<std::endl;
361            return 0;
362        }
363    }
364
365    typedef std::vector< ref_ptr<AttributeDispatch> >  AttributeDispatchList;
366    GLBeginEndAdapter*                  _glBeginEndAdapter;
367    AttributeDispatchList               _attributeDispatchList;
368    AttributeDispatchList               _attributeDispatchWithIndicesList;
369    AttributeDispatchList               _glBeginEndAttributeDispatchList;
370    AttributeDispatchList               _glBeginEndAttributeDispatchWithIndicesList;
371};
372
373ArrayDispatchers::ArrayDispatchers():
374    _initialized(false),
375    _state(0),
376    _glBeginEndAdapter(0),
377    _vertexDispatchers(0),
378    _normalDispatchers(0),
379    _colorDispatchers(0),
380    _secondaryColorDispatchers(0),
381    _fogCoordDispatchers(0),
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    _normalDispatchers->assignGLBeginEnd<GLfloat>(Array::Vec3ArrayType, &GLBeginEndAdapter::Normal3fv, 3);
433    _colorDispatchers->assignGLBeginEnd<GLubyte>(Array::Vec4ubArrayType, &GLBeginEndAdapter::Color4ubv, 4);
434    _colorDispatchers->assignGLBeginEnd<GLfloat>(Array::Vec4ArrayType, &GLBeginEndAdapter::Color4fv, 4);
435
436#ifdef OSG_GL_VERTEX_FUNCS_AVAILABLE
437    Drawable::Extensions* extensions = Drawable::getExtensions(_state->getContextID(),true);
438
439    #ifndef OSG_GLES1_AVAILABLE
440        _vertexDispatchers->assign<GLfloat>(Array::Vec2ArrayType, glVertex2fv, 2);
441        _vertexDispatchers->assign<GLfloat>(Array::Vec3ArrayType, glVertex3fv, 3);
442        _vertexDispatchers->assign<GLdouble>(Array::Vec2dArrayType, glVertex2dv, 2);
443        _vertexDispatchers->assign<GLdouble>(Array::Vec3dArrayType, glVertex3dv, 3);
444    #endif
445
446    _normalDispatchers->assign<GLbyte>(Array::Vec3bArrayType, glNormal3bv, 3);
447    _normalDispatchers->assign<GLshort>(Array::Vec3sArrayType, glNormal3sv, 3);
448    _normalDispatchers->assign<GLfloat>(Array::Vec3ArrayType, glNormal3fv, 3);
449    _normalDispatchers->assign<GLdouble>(Array::Vec3dArrayType, glNormal3dv, 3);
450
451    _colorDispatchers->assign<GLubyte>(Array::Vec4ubArrayType, glColor4ubv, 4);
452    _colorDispatchers->assign<GLfloat>(Array::Vec3ArrayType, glColor3fv, 3);
453    _colorDispatchers->assign<GLfloat>(Array::Vec4ArrayType, glColor4fv, 4);
454    _colorDispatchers->assign<GLdouble>(Array::Vec3dArrayType, glColor3dv, 3);
455    _colorDispatchers->assign<GLdouble>(Array::Vec4dArrayType, glColor4dv, 4);
456
457    _secondaryColorDispatchers->assign<GLfloat>(Array::Vec3ArrayType, extensions->_glSecondaryColor3fv, 3);
458
459    _fogCoordDispatchers->assign<GLfloat>(Array::FloatArrayType, extensions->_glFogCoordfv, 1);
460#endif
461
462    // pre allocate.
463    _activeDispatchList.resize(5);
464}
465
466AttributeDispatch* ArrayDispatchers::vertexDispatcher(Array* array, IndexArray* indices)
467{
468    return _useVertexAttribAlias ?
469           vertexAttribDispatcher(_state->getVertexAlias()._location, array, indices) :
470           _vertexDispatchers->dispatcher(_useGLBeginEndAdapter, array, indices);
471}
472
473AttributeDispatch* ArrayDispatchers::normalDispatcher(Array* array, IndexArray* indices)
474{
475    return _useVertexAttribAlias ?
476           vertexAttribDispatcher(_state->getNormalAlias()._location, array, indices) :
477           _normalDispatchers->dispatcher(_useGLBeginEndAdapter, array, indices);
478}
479
480AttributeDispatch* ArrayDispatchers::colorDispatcher(Array* array, IndexArray* indices)
481{
482    return _useVertexAttribAlias ?
483           vertexAttribDispatcher(_state->getColorAlias()._location, array, indices) :
484           _colorDispatchers->dispatcher(_useGLBeginEndAdapter, array, indices);
485}
486
487AttributeDispatch* ArrayDispatchers::secondaryColorDispatcher(Array* array, IndexArray* indices)
488{
489    return _useVertexAttribAlias ?
490           vertexAttribDispatcher(_state->getSecondaryColorAlias()._location, array, indices) :
491           _secondaryColorDispatchers->dispatcher(_useGLBeginEndAdapter, array, indices);
492}
493
494AttributeDispatch* ArrayDispatchers::fogCoordDispatcher(Array* array, IndexArray* indices)
495{
496    return _useVertexAttribAlias ?
497           vertexAttribDispatcher(_state->getFogCoordAlias()._location, array, indices) :
498           _fogCoordDispatchers->dispatcher(_useGLBeginEndAdapter, array, indices);
499}
500
501AttributeDispatch* ArrayDispatchers::texCoordDispatcher(unsigned int unit, Array* array, IndexArray* indices)
502{
503    if (_useVertexAttribAlias) return vertexAttribDispatcher(_state->getTexCoordAliasList()[unit]._location, array, indices);
504
505    if (unit>=_texCoordDispatchers.size()) assignTexCoordDispatchers(unit);
506    return _texCoordDispatchers[unit]->dispatcher(_useGLBeginEndAdapter, array, indices);
507}
508
509AttributeDispatch* ArrayDispatchers::vertexAttribDispatcher(unsigned int unit, Array* array, IndexArray* indices)
510{
511    if (unit>=_vertexAttribDispatchers.size()) assignVertexAttribDispatchers(unit);
512    return _vertexAttribDispatchers[unit]->dispatcher(_useGLBeginEndAdapter, array, indices);
513}
514
515void ArrayDispatchers::assignTexCoordDispatchers(unsigned int unit)
516{
517    #if defined(OSG_GL_VERTEX_FUNCS_AVAILABLE) && !defined(OSG_GLES1_AVAILABLE)
518    Drawable::Extensions* extensions = Drawable::getExtensions(_state->getContextID(),true);
519    #endif
520   
521    for(unsigned int i=_texCoordDispatchers.size(); i<=unit; ++i)
522    {
523        _texCoordDispatchers.push_back(new AttributeDispatchMap(_glBeginEndAdapter));
524        AttributeDispatchMap& texCoordDispatcher = *_texCoordDispatchers[i];
525        if (i==0)
526        {
527            #if defined(OSG_GL_VERTEX_FUNCS_AVAILABLE) && !defined(OSG_GLES1_AVAILABLE)
528            texCoordDispatcher.assign<GLfloat>(Array::FloatArrayType, glTexCoord1fv, 1);
529            texCoordDispatcher.assign<GLfloat>(Array::Vec2ArrayType, glTexCoord2fv, 2);
530            texCoordDispatcher.assign<GLfloat>(Array::Vec3ArrayType, glTexCoord3fv, 3);
531            texCoordDispatcher.assign<GLfloat>(Array::Vec4ArrayType, glTexCoord4fv, 4);
532            #endif
533            texCoordDispatcher.assignGLBeginEnd<GLfloat>(Array::FloatArrayType, &GLBeginEndAdapter::TexCoord1fv, 1);
534            texCoordDispatcher.assignGLBeginEnd<GLfloat>(Array::Vec2ArrayType, &GLBeginEndAdapter::TexCoord2fv, 2);
535            texCoordDispatcher.assignGLBeginEnd<GLfloat>(Array::Vec3ArrayType, &GLBeginEndAdapter::TexCoord3fv, 3);
536            texCoordDispatcher.assignGLBeginEnd<GLfloat>(Array::Vec4ArrayType, &GLBeginEndAdapter::TexCoord4fv, 4);
537        }
538        else
539        {
540            #if defined(OSG_GL_VERTEX_FUNCS_AVAILABLE) && !defined(OSG_GLES1_AVAILABLE)
541            texCoordDispatcher.targetAssign<GLenum, GLfloat>((GLenum)(GL_TEXTURE0+i), Array::FloatArrayType, extensions->_glMultiTexCoord1fv, 1);
542            texCoordDispatcher.targetAssign<GLenum, GLfloat>((GLenum)(GL_TEXTURE0+i), Array::Vec2ArrayType, extensions->_glMultiTexCoord2fv, 2);
543            texCoordDispatcher.targetAssign<GLenum, GLfloat>((GLenum)(GL_TEXTURE0+i), Array::Vec3ArrayType, extensions->_glMultiTexCoord3fv, 3);
544            texCoordDispatcher.targetAssign<GLenum, GLfloat>((GLenum)(GL_TEXTURE0+i), Array::Vec4ArrayType, extensions->_glMultiTexCoord4fv, 4);
545            #endif
546            texCoordDispatcher.targetGLBeginEndAssign<GLenum, GLfloat>((GLenum)(GL_TEXTURE0+i), Array::FloatArrayType, &GLBeginEndAdapter::MultiTexCoord1fv, 1);
547            texCoordDispatcher.targetGLBeginEndAssign<GLenum, GLfloat>((GLenum)(GL_TEXTURE0+i), Array::Vec2ArrayType, &GLBeginEndAdapter::MultiTexCoord2fv, 2);
548            texCoordDispatcher.targetGLBeginEndAssign<GLenum, GLfloat>((GLenum)(GL_TEXTURE0+i), Array::Vec3ArrayType, &GLBeginEndAdapter::MultiTexCoord3fv, 3);
549            texCoordDispatcher.targetGLBeginEndAssign<GLenum, GLfloat>((GLenum)(GL_TEXTURE0+i), Array::Vec4ArrayType, &GLBeginEndAdapter::MultiTexCoord4fv, 4);
550        }
551    }
552
553}
554
555void ArrayDispatchers::assignVertexAttribDispatchers(unsigned int unit)
556{
557    Drawable::Extensions* extensions = Drawable::getExtensions(_state->getContextID(),true);
558
559    for(unsigned int i=_vertexAttribDispatchers.size(); i<=unit; ++i)
560    {
561        _vertexAttribDispatchers.push_back(new AttributeDispatchMap(_glBeginEndAdapter));
562        AttributeDispatchMap& vertexAttribDispatcher = *_vertexAttribDispatchers[i];
563        vertexAttribDispatcher.targetAssign<GLuint, GLfloat>(i, Array::FloatArrayType, extensions->_glVertexAttrib1fv, 1);
564        vertexAttribDispatcher.targetAssign<GLuint, GLfloat>(i, Array::Vec2ArrayType, extensions->_glVertexAttrib2fv, 2);
565        vertexAttribDispatcher.targetAssign<GLuint, GLfloat>(i, Array::Vec3ArrayType, extensions->_glVertexAttrib3fv, 3);
566        vertexAttribDispatcher.targetAssign<GLuint, GLfloat>(i, Array::Vec4ArrayType, extensions->_glVertexAttrib4fv, 4);
567        vertexAttribDispatcher.targetGLBeginEndAssign<GLenum, GLfloat>(i, Array::FloatArrayType, &GLBeginEndAdapter::VertexAttrib1fv, 1);
568        vertexAttribDispatcher.targetGLBeginEndAssign<GLenum, GLfloat>(i, Array::Vec2ArrayType, &GLBeginEndAdapter::VertexAttrib2fv, 2);
569        vertexAttribDispatcher.targetGLBeginEndAssign<GLenum, GLfloat>(i, Array::Vec3ArrayType, &GLBeginEndAdapter::VertexAttrib3fv, 3);
570        vertexAttribDispatcher.targetGLBeginEndAssign<GLenum, GLfloat>(i, Array::Vec4ArrayType, &GLBeginEndAdapter::VertexAttrib4fv, 4);
571    }
572}
573
574void ArrayDispatchers::reset()
575{
576    if (!_initialized) init();
577
578    _useGLBeginEndAdapter = false;
579
580    for(ActiveDispatchList::iterator itr = _activeDispatchList.begin();
581        itr != _activeDispatchList.end();
582        ++itr)
583    {
584        (*itr).clear();
585    }
586}
587
588}
Note: See TracBrowser for help on using the browser.