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

Revision 11903, 23.0 kB (checked in by robert, 3 years ago)

Refactored the versioning of serializers so it now uses a _firstVersion and _lastVersion make it possible
to specify what range of versions support each serializer.

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