root/OpenSceneGraph/trunk/src/osgDB/ObjectWrapper.cpp @ 13788

Revision 13788, 25.7 kB (checked in by robert, 7 days ago)

Fixed comment

  • Property svn:eol-style set to native
Line 
1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2010 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// Written by Wang Rui, (C) 2010
14
15#include <osg/Version>
16#include <osg/Notify>
17#include <osg/BlendFunc>
18#include <osg/ClampColor>
19#include <osg/Fog>
20#include <osg/FragmentProgram>
21#include <osg/GL2Extensions>
22#include <osg/PointSprite>
23#include <osg/StateSet>
24#include <osg/StencilTwoSided>
25#include <osg/TexEnvCombine>
26#include <osg/Texture>
27#include <osg/TextureCubeMap>
28#include <osg/TextureRectangle>
29#include <osg/VertexProgram>
30
31#include <osgDB/Options>
32#include <osgDB/DataTypes>
33#include <osgDB/ObjectWrapper>
34#include <osgDB/Registry>
35
36// pull in OSG headers to just introduce their GL defines for GL3/GLES compatibility
37#include <osg/AlphaFunc>
38#include <osg/Material>
39#include <osg/LineStipple>
40#include <osg/PolygonStipple>
41#include <osg/Point>
42#include <osg/TexGen>
43#include <osg/ClipPlane>
44#include <osg/Fog>
45#include <osg/PolygonMode>
46#include <osg/PolygonOffset>
47#include <osg/Texture1D>
48#include <osg/LogicOp>
49
50#include <sstream>
51
52#ifndef GL_PERSPECTIVE_CORRECTION_HINT
53    #define GL_PERSPECTIVE_CORRECTION_HINT      0x0C50
54#endif
55
56#if defined(OSG_GLES1_AVAILABLE) || defined(OSG_GLES2_AVAILABLE)
57    #define GL_POLYGON_SMOOTH_HINT              0x0C53
58    #define GL_LINE_SMOOTH_HINT                 0x0C52
59    #define GL_FRAGMENT_SHADER_DERIVATIVE_HINT  0x8B8B
60#endif
61
62using namespace osgDB;
63
64void osgDB::split( const std::string& src, StringList& list, char separator )
65{
66    std::string::size_type start = src.find_first_not_of(separator);
67    while ( start!=std::string::npos )
68    {
69        std::string::size_type end = src.find_first_of(separator, start);
70        if ( end!=std::string::npos )
71        {
72            list.push_back( std::string(src, start, end-start) );
73            start = src.find_first_not_of(separator, end);
74        }
75        else
76        {
77            list.push_back( std::string(src, start, src.size()-start) );
78            start = end;
79        }
80    }
81}
82
83////////////////////////////////////////////////////////////////////////////////////////////////////////
84//
85// ObjectWrapper
86//
87ObjectWrapper::ObjectWrapper( osg::Object* proto, const std::string& name,
88                              const std::string& associates )
89:   osg::Referenced(),
90    _proto(proto), _name(name), _version(0)
91{
92    split( associates, _associates );
93}
94
95ObjectWrapper::ObjectWrapper( osg::Object* proto, const std::string& domain, const std::string& name,
96                              const std::string& associates )
97:   osg::Referenced(),
98    _proto(proto), _domain(domain), _name(name), _version(0)
99{
100    split( associates, _associates );
101}
102
103void ObjectWrapper::addSerializer( BaseSerializer* s, BaseSerializer::Type t )
104{
105    s->_firstVersion = _version;
106    _serializers.push_back(s);
107    _typeList.push_back(static_cast<int>(t));
108}
109
110void ObjectWrapper::markSerializerAsRemoved( const std::string& name )
111{
112    for ( SerializerList::iterator itr=_serializers.begin(); itr!=_serializers.end(); ++itr )
113    {
114        // When a serializer is marked as 'removed', it means that this serializer won't be used any more
115        // from specified OSG version (by macro UPDATE_TO_VERSION). The read() functions of higher versions
116        // will thus ignore it according to the sign and value of the _version variable.
117        if ( (*itr)->getName()==name )
118            (*itr)->_lastVersion = _version-1;
119    }
120}
121
122BaseSerializer* ObjectWrapper::getSerializer( const std::string& name )
123{
124    for ( SerializerList::iterator itr=_serializers.begin(); itr!=_serializers.end(); ++itr )
125    {
126        if ( (*itr)->getName()==name )
127            return itr->get();
128    }
129
130    for ( StringList::const_iterator itr=_associates.begin(); itr!=_associates.end(); ++itr )
131    {
132        const std::string& assocName = *itr;
133        ObjectWrapper* assocWrapper = Registry::instance()->getObjectWrapperManager()->findWrapper(assocName);
134        if ( !assocWrapper )
135        {
136            osg::notify(osg::WARN) << "ObjectWrapper::getSerializer(): Unsupported associated class "
137                                   << assocName << std::endl;
138            continue;
139        }
140
141        for ( SerializerList::iterator aitr=assocWrapper->_serializers.begin();
142              aitr!=assocWrapper->_serializers.end(); ++aitr )
143        {
144            if ( (*aitr)->getName()==name )
145                return aitr->get();
146        }
147    }
148    return NULL;
149}
150
151bool ObjectWrapper::read( InputStream& is, osg::Object& obj )
152{
153    bool readOK = true;
154    int inputVersion = is.getFileVersion(_domain);
155    for ( SerializerList::iterator itr=_serializers.begin();
156          itr!=_serializers.end(); ++itr )
157    {
158        BaseSerializer* serializer = itr->get();
159        if ( serializer->_firstVersion <= inputVersion &&
160             inputVersion <= serializer->_lastVersion )
161        {
162            if ( !serializer->read(is, obj) )
163            {
164                OSG_WARN << "ObjectWrapper::read(): Error reading property "
165                                    << _name << "::" << (*itr)->getName() << std::endl;
166                readOK = false;
167            }
168        }
169        else
170        {
171            // OSG_NOTICE<<"Ignoring serializer due to version mismatch"<<std::endl;
172        }
173    }
174
175    for ( FinishedObjectReadCallbackList::iterator itr=_finishedObjectReadCallbacks.begin();
176          itr!=_finishedObjectReadCallbacks.end();
177          ++itr )
178     {
179         (*itr)->objectRead(is, obj);
180     }
181
182    return readOK;
183}
184
185bool ObjectWrapper::write( OutputStream& os, const osg::Object& obj )
186{
187    bool writeOK = true;
188    int outputVersion = os.getFileVersion(_domain);
189    for ( SerializerList::iterator itr=_serializers.begin();
190          itr!=_serializers.end(); ++itr )
191    {
192        BaseSerializer* serializer = itr->get();
193        if ( serializer->_firstVersion <= outputVersion &&
194             outputVersion <= serializer->_lastVersion )
195        {
196            if ( !serializer->write(os, obj) )
197            {
198                OSG_WARN << "ObjectWrapper::write(): Error writing property "
199                                    << _name << "::" << (*itr)->getName() << std::endl;
200                writeOK = false;
201            }
202        }
203        else
204        {
205            // OSG_NOTICE<<"Ignoring serializer due to version mismatch"<<std::endl;
206        }
207    }
208    return writeOK;
209}
210
211bool ObjectWrapper::readSchema( const StringList& properties, const std::vector<int>& )
212{
213    // FIXME: At present, I didn't do anything to determine serializers from their types...
214    if ( !_backupSerializers.size() )
215        _backupSerializers = _serializers;
216    _serializers.clear();
217
218    unsigned int size = properties.size();
219    unsigned int serializersSize = _backupSerializers.size();
220    for ( unsigned int i=0; i<size; ++i )
221    {
222        if ( serializersSize<i )
223        {
224            OSG_WARN << "ObjectWrapper::readSchema(): Wrapper " << _name
225                                   << ": Incompatible serializers size" << std::endl;
226            break;
227        }
228
229        const std::string& prop = properties[i];
230        if ( prop==_backupSerializers[i]->getName() )
231        {
232            _serializers.push_back( _backupSerializers[i] );
233        }
234        else
235        {
236            bool hasSerializer = false;
237            for ( SerializerList::iterator itr=_backupSerializers.begin();
238                  itr!=_backupSerializers.end(); ++itr )
239            {
240                if ( prop!=(*itr)->getName() ) continue;
241                _serializers.push_back( *itr );
242                hasSerializer = true;
243            }
244            if ( !hasSerializer )
245            {
246                OSG_WARN << "ObjectWrapper::readSchema(): Wrapper " << _name
247                                       << ": Unknown property " << prop << std::endl;
248            }
249        }
250    }
251    return size==_serializers.size();
252}
253
254void ObjectWrapper::writeSchema( StringList& properties, std::vector<int>& types )
255{
256    for ( SerializerList::iterator itr=_serializers.begin();
257          itr!=_serializers.end(); ++itr )
258    {
259        properties.push_back( (*itr)->getName() );
260    }
261
262    for ( std::vector<int>::iterator itr=_typeList.begin();
263          itr!=_typeList.end(); ++itr )
264    {
265        types.push_back( (*itr) );
266    }
267}
268
269////////////////////////////////////////////////////////////////////////////////////////////////////////
270//
271// RegisterWrapperProxy
272//
273RegisterWrapperProxy::RegisterWrapperProxy( osg::Object* proto, const std::string& name,
274                        const std::string& associates, AddPropFunc func )
275{
276    _wrapper = new ObjectWrapper( proto, name, associates );
277    if ( func ) (*func)( _wrapper.get() );
278
279    if (Registry::instance())
280    {
281        Registry::instance()->getObjectWrapperManager()->addWrapper( _wrapper.get() );
282    }
283}
284
285RegisterWrapperProxy::~RegisterWrapperProxy()
286{
287    if (Registry::instance())
288    {
289        Registry::instance()->getObjectWrapperManager()->removeWrapper( _wrapper.get() );
290    }
291}
292
293////////////////////////////////////////////////////////////////////////////////////////////////////////
294//
295// RegisterCustomWrapperProxy
296//
297RegisterCustomWrapperProxy::RegisterCustomWrapperProxy(
298        osg::Object* proto, const std::string& domain, const std::string& name,
299        const std::string& associates, AddPropFunc func )
300{
301    _wrapper = new ObjectWrapper( proto, domain, name, associates );
302    if ( func ) (*func)( domain.c_str(), _wrapper.get() );
303
304    if (Registry::instance())
305    {
306        Registry::instance()->getObjectWrapperManager()->addWrapper( _wrapper.get() );
307    }
308}
309
310RegisterCustomWrapperProxy::~RegisterCustomWrapperProxy()
311{
312    if (Registry::instance())
313    {
314        Registry::instance()->getObjectWrapperManager()->removeWrapper( _wrapper.get() );
315    }
316}
317
318////////////////////////////////////////////////////////////////////////////////////////////////////////
319//
320// ObjectWrapperManager
321//
322////////////////////////////////////////////////////////////////////////////////////////////////////////
323//
324// GlobalLookupTable
325//
326ObjectWrapperManager::ObjectWrapperManager()
327{
328    IntLookup& glTable = _globalMap["GL"];
329
330    // Modes
331    glTable.add( "GL_ALPHA_TEST", GL_ALPHA_TEST );
332    glTable.add( "GL_BLEND", GL_BLEND );
333    glTable.add( "GL_COLOR_LOGIC_OP", GL_COLOR_LOGIC_OP );
334    glTable.add( "GL_COLOR_MATERIAL", GL_COLOR_MATERIAL );
335    glTable.add( "GL_CULL_FACE", GL_CULL_FACE );
336    glTable.add( "GL_DEPTH_TEST", GL_DEPTH_TEST );
337    glTable.add( "GL_FOG", GL_FOG );
338    glTable.add( "GL_FRAGMENT_PROGRAM_ARB", GL_FRAGMENT_PROGRAM_ARB );
339    glTable.add( "GL_LINE_STIPPLE", GL_LINE_STIPPLE );
340    glTable.add( "GL_POINT_SMOOTH", GL_POINT_SMOOTH );
341    glTable.add( "GL_POINT_SPRITE_ARB", GL_POINT_SPRITE_ARB );
342    glTable.add( "GL_POLYGON_OFFSET_FILL", GL_POLYGON_OFFSET_FILL );
343    glTable.add( "GL_POLYGON_OFFSET_LINE", GL_POLYGON_OFFSET_LINE );
344    glTable.add( "GL_POLYGON_OFFSET_POINT", GL_POLYGON_OFFSET_POINT );
345    glTable.add( "GL_POLYGON_STIPPLE", GL_POLYGON_STIPPLE );
346    glTable.add( "GL_SCISSOR_TEST", GL_SCISSOR_TEST);
347    glTable.add( "GL_STENCIL_TEST", GL_STENCIL_TEST );
348    glTable.add( "GL_STENCIL_TEST_TWO_SIDE", GL_STENCIL_TEST_TWO_SIDE );
349    glTable.add( "GL_VERTEX_PROGRAM_ARB", GL_VERTEX_PROGRAM_ARB );
350
351    glTable.add( "GL_COLOR_SUM", GL_COLOR_SUM );
352    glTable.add( "GL_LIGHTING", GL_LIGHTING );
353    glTable.add( "GL_NORMALIZE", GL_NORMALIZE );
354    glTable.add( "GL_RESCALE_NORMAL", GL_RESCALE_NORMAL );
355
356    glTable.add( "GL_TEXTURE_1D", GL_TEXTURE_1D );
357    glTable.add( "GL_TEXTURE_2D", GL_TEXTURE_2D );
358    glTable.add( "GL_TEXTURE_3D", GL_TEXTURE_3D );
359    glTable.add( "GL_TEXTURE_CUBE_MAP", GL_TEXTURE_CUBE_MAP );
360    glTable.add( "GL_TEXTURE_RECTANGLE", GL_TEXTURE_RECTANGLE );
361    glTable.add( "GL_TEXTURE_GEN_Q", GL_TEXTURE_GEN_Q );
362    glTable.add( "GL_TEXTURE_GEN_R", GL_TEXTURE_GEN_R );
363    glTable.add( "GL_TEXTURE_GEN_S", GL_TEXTURE_GEN_S );
364    glTable.add( "GL_TEXTURE_GEN_T", GL_TEXTURE_GEN_T );
365
366    glTable.add( "GL_CLIP_PLANE0", GL_CLIP_PLANE0 );
367    glTable.add( "GL_CLIP_PLANE1", GL_CLIP_PLANE1 );
368    glTable.add( "GL_CLIP_PLANE2", GL_CLIP_PLANE2 );
369    glTable.add( "GL_CLIP_PLANE3", GL_CLIP_PLANE3 );
370    glTable.add( "GL_CLIP_PLANE4", GL_CLIP_PLANE4 );
371    glTable.add( "GL_CLIP_PLANE5", GL_CLIP_PLANE5 );
372
373    glTable.add( "GL_LIGHT0", GL_LIGHT0 );
374    glTable.add( "GL_LIGHT1", GL_LIGHT1 );
375    glTable.add( "GL_LIGHT2", GL_LIGHT2 );
376    glTable.add( "GL_LIGHT3", GL_LIGHT3 );
377    glTable.add( "GL_LIGHT4", GL_LIGHT4 );
378    glTable.add( "GL_LIGHT5", GL_LIGHT5 );
379    glTable.add( "GL_LIGHT6", GL_LIGHT6 );
380    glTable.add( "GL_LIGHT7", GL_LIGHT7 );
381
382    // Functions
383    glTable.add( "NEVER", GL_NEVER );
384    glTable.add( "LESS", GL_LESS );
385    glTable.add( "EQUAL", GL_EQUAL );
386    glTable.add( "LEQUAL", GL_LEQUAL );
387    glTable.add( "GREATER", GL_GREATER );
388    glTable.add( "NOTEQUAL", GL_NOTEQUAL );
389    glTable.add( "GEQUAL", GL_GEQUAL );
390    glTable.add( "ALWAYS", GL_ALWAYS );
391
392    // Texture environment states
393    glTable.add( "REPLACE", GL_REPLACE );
394    glTable.add( "MODULATE", GL_MODULATE );
395    glTable.add( "ADD", GL_ADD );
396    glTable.add( "ADD_SIGNED", GL_ADD_SIGNED_ARB );
397    glTable.add( "INTERPOLATE", GL_INTERPOLATE_ARB );
398    glTable.add( "SUBTRACT", GL_SUBTRACT_ARB );
399    glTable.add( "DOT3_RGB", GL_DOT3_RGB_ARB );
400    glTable.add( "DOT3_RGBA", GL_DOT3_RGBA_ARB );
401
402    glTable.add( "CONSTANT", GL_CONSTANT_ARB );
403    glTable.add( "PRIMARY_COLOR", GL_PRIMARY_COLOR_ARB );
404    glTable.add( "PREVIOUS", GL_PREVIOUS_ARB );
405    glTable.add( "TEXTURE", GL_TEXTURE );
406    glTable.add( "TEXTURE0", GL_TEXTURE0 );
407    glTable.add( "TEXTURE1", GL_TEXTURE0+1 );
408    glTable.add( "TEXTURE2", GL_TEXTURE0+2 );
409    glTable.add( "TEXTURE3", GL_TEXTURE0+3 );
410    glTable.add( "TEXTURE4", GL_TEXTURE0+4 );
411    glTable.add( "TEXTURE5", GL_TEXTURE0+5 );
412    glTable.add( "TEXTURE6", GL_TEXTURE0+6 );
413    glTable.add( "TEXTURE7", GL_TEXTURE0+7 );
414
415    // Texture clamp modes
416    glTable.add( "CLAMP", GL_CLAMP );
417    glTable.add( "CLAMP_TO_EDGE", GL_CLAMP_TO_EDGE );
418    glTable.add( "CLAMP_TO_BORDER", GL_CLAMP_TO_BORDER_ARB );
419    glTable.add( "REPEAT", GL_REPEAT );
420    glTable.add( "MIRROR", GL_MIRRORED_REPEAT_IBM );
421
422    // Texture filter modes
423    glTable.add( "LINEAR", GL_LINEAR );
424    glTable.add( "LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR );
425    glTable.add( "LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST );
426    glTable.add( "NEAREST", GL_NEAREST );
427    glTable.add( "NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR );
428    glTable.add( "NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST );
429
430    // Texture formats
431    glTable.add( "GL_INTENSITY", GL_INTENSITY );
432    glTable.add( "GL_LUMINANCE", GL_LUMINANCE );
433    glTable.add( "GL_ALPHA", GL_ALPHA );
434    glTable.add( "GL_LUMINANCE_ALPHA", GL_LUMINANCE_ALPHA );
435    glTable.add( "GL_RGB", GL_RGB );
436    glTable.add( "GL_RGBA", GL_RGBA );
437    glTable.add( "GL_COMPRESSED_ALPHA_ARB", GL_COMPRESSED_ALPHA_ARB );
438    glTable.add( "GL_COMPRESSED_LUMINANCE_ARB", GL_COMPRESSED_LUMINANCE_ARB );
439    glTable.add( "GL_COMPRESSED_INTENSITY_ARB", GL_COMPRESSED_INTENSITY_ARB );
440    glTable.add( "GL_COMPRESSED_LUMINANCE_ALPHA_ARB", GL_COMPRESSED_LUMINANCE_ALPHA_ARB );
441    glTable.add( "GL_COMPRESSED_RGB_ARB", GL_COMPRESSED_RGB_ARB );
442    glTable.add( "GL_COMPRESSED_RGBA_ARB", GL_COMPRESSED_RGBA_ARB );
443    glTable.add( "GL_COMPRESSED_RGB_S3TC_DXT1_EXT", GL_COMPRESSED_RGB_S3TC_DXT1_EXT );
444    glTable.add( "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT", GL_COMPRESSED_RGBA_S3TC_DXT1_EXT );
445    glTable.add( "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT", GL_COMPRESSED_RGBA_S3TC_DXT3_EXT );
446    glTable.add( "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT", GL_COMPRESSED_RGBA_S3TC_DXT5_EXT );
447    glTable.add( "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG",GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG );
448    glTable.add( "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG",GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG );
449    glTable.add( "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG",GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG );
450    glTable.add( "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG",GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG );
451    glTable.add( "GL_ETC1_RGB8_OES",GL_ETC1_RGB8_OES );
452
453    // Texture source types
454    glTable.add( "GL_BYTE", GL_BYTE );
455    glTable.add( "GL_SHORT", GL_SHORT );
456    glTable.add( "GL_INT", GL_INT );
457    glTable.add( "GL_FLOAT", GL_FLOAT );
458    glTable.add( "GL_DOUBLE", GL_DOUBLE );
459    glTable.add( "GL_UNSIGNED_BYTE", GL_UNSIGNED_BYTE );
460    glTable.add( "GL_UNSIGNED_SHORT", GL_UNSIGNED_SHORT );
461    glTable.add( "GL_UNSIGNED_INT", GL_UNSIGNED_INT );
462
463    // Blend values
464    glTable.add( "DST_ALPHA", GL_DST_ALPHA );
465    glTable.add( "DST_COLOR", GL_DST_COLOR );
466    glTable.add( "ONE", GL_ONE );
467    glTable.add( "ONE_MINUS_DST_ALPHA", GL_ONE_MINUS_DST_ALPHA );
468    glTable.add( "ONE_MINUS_DST_COLOR", GL_ONE_MINUS_DST_COLOR );
469    glTable.add( "ONE_MINUS_SRC_ALPHA", GL_ONE_MINUS_SRC_ALPHA );
470    glTable.add( "ONE_MINUS_SRC_COLOR", GL_ONE_MINUS_SRC_COLOR );
471    glTable.add( "SRC_ALPHA", GL_SRC_ALPHA );
472    glTable.add( "SRC_ALPHA_SATURATE", GL_SRC_ALPHA_SATURATE );
473    glTable.add( "SRC_COLOR", GL_SRC_COLOR );
474    glTable.add( "CONSTANT_COLOR", GL_CONSTANT_COLOR );
475    glTable.add( "ONE_MINUS_CONSTANT_COLOR", GL_ONE_MINUS_CONSTANT_COLOR );
476    glTable.add( "CONSTANT_ALPHA", GL_CONSTANT_ALPHA );
477    glTable.add( "ONE_MINUS_CONSTANT_ALPHA", GL_ONE_MINUS_CONSTANT_ALPHA );
478    glTable.add( "ZERO", GL_ZERO );
479
480    // Fog coordinate sources
481    glTable.add( "COORDINATE", GL_FOG_COORDINATE );
482    glTable.add( "DEPTH", GL_FRAGMENT_DEPTH );
483
484    // Hint targets
485    glTable.add( "FOG_HINT", GL_FOG_HINT );
486    glTable.add( "GENERATE_MIPMAP_HINT", GL_GENERATE_MIPMAP_HINT_SGIS );
487    glTable.add( "LINE_SMOOTH_HINT", GL_LINE_SMOOTH_HINT );
488    glTable.add( "PERSPECTIVE_CORRECTION_HINT", GL_PERSPECTIVE_CORRECTION_HINT );
489    glTable.add( "POINT_SMOOTH_HINT", GL_POINT_SMOOTH_HINT );
490    glTable.add( "POLYGON_SMOOTH_HINT", GL_POLYGON_SMOOTH_HINT );
491    glTable.add( "TEXTURE_COMPRESSION_HINT", GL_TEXTURE_COMPRESSION_HINT_ARB );
492    glTable.add( "FRAGMENT_SHADER_DERIVATIVE_HINT", GL_FRAGMENT_SHADER_DERIVATIVE_HINT );
493
494    // Polygon modes
495    glTable.add( "POINT", GL_POINT );
496    glTable.add( "LINE", GL_LINE );
497    glTable.add( "FILL", GL_FILL );
498
499    // Misc
500    glTable.add( "BACK", GL_BACK );
501    glTable.add( "FRONT", GL_FRONT );
502    glTable.add( "FRONT_AND_BACK", GL_FRONT_AND_BACK );
503    glTable.add( "FIXED_ONLY", GL_FIXED_ONLY );
504    glTable.add( "FASTEST", GL_FASTEST );
505    glTable.add( "NICEST", GL_NICEST );
506    glTable.add( "DONT_CARE", GL_DONT_CARE );
507
508    IntLookup& arrayTable = _globalMap["ArrayType"];
509
510    arrayTable.add( "ByteArray", ID_BYTE_ARRAY );
511    arrayTable.add( "UByteArray", ID_UBYTE_ARRAY );
512    arrayTable.add( "ShortArray", ID_SHORT_ARRAY );
513    arrayTable.add( "UShortArray", ID_USHORT_ARRAY );
514    arrayTable.add( "IntArray", ID_INT_ARRAY );
515    arrayTable.add( "UIntArray", ID_UINT_ARRAY );
516    arrayTable.add( "FloatArray", ID_FLOAT_ARRAY );
517    arrayTable.add( "DoubleArray", ID_DOUBLE_ARRAY );
518
519    arrayTable.add( "Vec2bArray", ID_VEC2B_ARRAY );
520    arrayTable.add( "Vec3bArray", ID_VEC3B_ARRAY );
521    arrayTable.add( "Vec4bArray", ID_VEC4B_ARRAY );
522    arrayTable.add( "Vec2ubArray", ID_VEC2UB_ARRAY );
523    arrayTable.add( "Vec3ubArray", ID_VEC3UB_ARRAY );
524    arrayTable.add( "Vec4ubArray", ID_VEC4UB_ARRAY );
525    arrayTable.add( "Vec2sArray", ID_VEC2S_ARRAY );
526    arrayTable.add( "Vec3sArray", ID_VEC3S_ARRAY );
527    arrayTable.add( "Vec4sArray", ID_VEC4S_ARRAY );
528    arrayTable.add( "Vec2usArray", ID_VEC2US_ARRAY );
529    arrayTable.add( "Vec3usArray", ID_VEC3US_ARRAY );
530    arrayTable.add( "Vec4usArray", ID_VEC4US_ARRAY );
531    arrayTable.add( "Vec2fArray", ID_VEC2_ARRAY );
532    arrayTable.add( "Vec3fArray", ID_VEC3_ARRAY );
533    arrayTable.add( "Vec4fArray", ID_VEC4_ARRAY );
534    arrayTable.add( "Vec2dArray", ID_VEC2D_ARRAY );
535    arrayTable.add( "Vec3dArray", ID_VEC3D_ARRAY );
536    arrayTable.add( "Vec4dArray", ID_VEC4D_ARRAY );
537
538    arrayTable.add( "Vec2iArray", ID_VEC2I_ARRAY );
539    arrayTable.add( "Vec3iArray", ID_VEC3I_ARRAY );
540    arrayTable.add( "Vec4iArray", ID_VEC4I_ARRAY );
541    arrayTable.add( "Vec2uiArray", ID_VEC2UI_ARRAY );
542    arrayTable.add( "Vec3uiArray", ID_VEC3UI_ARRAY );
543    arrayTable.add( "Vec4uiArray", ID_VEC4UI_ARRAY );
544
545    IntLookup& primitiveTable = _globalMap["PrimitiveType"];
546
547    primitiveTable.add( "DrawArrays", ID_DRAWARRAYS );
548    primitiveTable.add( "DrawArraysLength", ID_DRAWARRAY_LENGTH );
549    primitiveTable.add( "DrawElementsUByte", ID_DRAWELEMENTS_UBYTE );
550    primitiveTable.add( "DrawElementsUShort", ID_DRAWELEMENTS_USHORT );
551    primitiveTable.add( "DrawElementsUInt", ID_DRAWELEMENTS_UINT );
552
553    primitiveTable.add( "GL_POINTS", GL_POINTS );
554    primitiveTable.add( "GL_LINES", GL_LINES );
555    primitiveTable.add( "GL_LINE_STRIP", GL_LINE_STRIP );
556    primitiveTable.add( "GL_LINE_LOOP", GL_LINE_LOOP );
557    primitiveTable.add( "GL_TRIANGLES", GL_TRIANGLES );
558    primitiveTable.add( "GL_TRIANGLE_STRIP", GL_TRIANGLE_STRIP );
559    primitiveTable.add( "GL_TRIANGLE_FAN", GL_TRIANGLE_FAN );
560    primitiveTable.add( "GL_QUADS", GL_QUADS );
561    primitiveTable.add( "GL_QUAD_STRIP", GL_QUAD_STRIP );
562    primitiveTable.add( "GL_POLYGON", GL_POLYGON );
563    primitiveTable.add( "GL_LINES_ADJACENCY_EXT", GL_LINES_ADJACENCY_EXT );
564    primitiveTable.add( "GL_LINE_STRIP_ADJACENCY_EXT", GL_LINE_STRIP_ADJACENCY_EXT );
565    primitiveTable.add( "GL_TRIANGLES_ADJACENCY_EXT", GL_TRIANGLES_ADJACENCY_EXT );
566    primitiveTable.add( "GL_TRIANGLE_STRIP_ADJACENCY_EXT", GL_TRIANGLE_STRIP_ADJACENCY_EXT );
567    primitiveTable.add( "GL_PATCHES", GL_PATCHES );
568}
569
570ObjectWrapperManager::~ObjectWrapperManager()
571{
572}
573
574
575void ObjectWrapperManager::addWrapper( ObjectWrapper* wrapper )
576{
577    if ( !wrapper ) return;
578
579    WrapperMap::iterator itr = _wrappers.find( wrapper->getName() );
580    if ( itr!=_wrappers.end() )
581    {
582        OSG_WARN << "ObjectWrapperManager::addWrapper(): '" << wrapper->getName()
583                               << "' already exists." << std::endl;
584    }
585    _wrappers[wrapper->getName()] = wrapper;
586}
587
588void ObjectWrapperManager::removeWrapper( ObjectWrapper* wrapper )
589{
590    if ( !wrapper ) return;
591
592    WrapperMap::iterator itr = _wrappers.find( wrapper->getName() );
593    if ( itr!=_wrappers.end() ) _wrappers.erase( itr );
594}
595
596ObjectWrapper* ObjectWrapperManager::findWrapper( const std::string& name )
597{
598    WrapperMap::iterator itr = _wrappers.find( name );
599    if ( itr!=_wrappers.end() ) return itr->second.get();
600
601    // Load external libraries
602    std::string::size_type posDoubleColon = name.rfind("::");
603    if ( posDoubleColon!=std::string::npos )
604    {
605        std::string libName = std::string( name, 0, posDoubleColon );
606
607        std::string nodeKitLib = osgDB::Registry::instance()->createLibraryNameForNodeKit(libName);
608        if ( osgDB::Registry::instance()->loadLibrary(nodeKitLib)==osgDB::Registry::LOADED )
609            return findWrapper(name);
610
611        std::string pluginLib = osgDB::Registry::instance()->createLibraryNameForExtension(std::string("serializers_")+libName);
612        if ( osgDB::Registry::instance()->loadLibrary(pluginLib)==osgDB::Registry::LOADED )
613            return findWrapper(name);
614
615        pluginLib = osgDB::Registry::instance()->createLibraryNameForExtension(libName);
616        if ( osgDB::Registry::instance()->loadLibrary(pluginLib)==osgDB::Registry::LOADED )
617            return findWrapper(name);
618    }
619    return NULL;
620}
621
622void ObjectWrapperManager::addCompressor( BaseCompressor* compressor )
623{
624    if ( !compressor ) return;
625
626    CompressorMap::iterator itr = _compressors.find( compressor->getName() );
627    if ( itr!=_compressors.end() )
628    {
629        OSG_WARN << "ObjectWrapperManager::addCompressor(): '" << compressor->getName()
630                               << "' already exists." << std::endl;
631    }
632    _compressors[compressor->getName()] = compressor;
633}
634
635void ObjectWrapperManager::removeCompressor( BaseCompressor* compressor )
636{
637    if ( !compressor ) return;
638
639    CompressorMap::iterator itr = _compressors.find( compressor->getName() );
640    if ( itr!=_compressors.end() ) _compressors.erase( itr );
641}
642
643BaseCompressor* ObjectWrapperManager::findCompressor( const std::string& name )
644{
645    CompressorMap::iterator itr = _compressors.find( name );
646    if ( itr!=_compressors.end() ) return itr->second.get();
647
648    // Load external libraries
649    std::string nodeKitLib = osgDB::Registry::instance()->createLibraryNameForNodeKit(name);
650    if ( osgDB::Registry::instance()->loadLibrary(nodeKitLib)==osgDB::Registry::LOADED )
651        return findCompressor(name);
652
653    std::string pluginLib = osgDB::Registry::instance()->createLibraryNameForExtension(std::string("compressor_")+name);
654    if ( osgDB::Registry::instance()->loadLibrary(pluginLib)==osgDB::Registry::LOADED )
655        return findCompressor(name);
656
657    pluginLib = osgDB::Registry::instance()->createLibraryNameForExtension(name);
658    if ( osgDB::Registry::instance()->loadLibrary(pluginLib)==osgDB::Registry::LOADED )
659        return findCompressor(name);
660    return NULL;
661}
662
663////////////////////////////////////////////////////////////////////////////////////////////////////////
664//
665// RegisytrCompressorProxy
666//
667RegisterCompressorProxy::RegisterCompressorProxy( const std::string& name, BaseCompressor* compressor ):
668    _compressor(compressor)
669{
670    _compressor->setName( name );
671    if (Registry::instance())
672    {
673        Registry::instance()->getObjectWrapperManager()->addCompressor( _compressor.get() );
674    }
675}
676
677RegisterCompressorProxy::~RegisterCompressorProxy()
678{
679    if (Registry::instance())
680    {
681        Registry::instance()->getObjectWrapperManager()->removeCompressor( _compressor.get() );
682    }
683}
Note: See TracBrowser for help on using the browser.