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

Revision 13041, 24.0 kB (checked in by robert, 14 months ago)

Ran script to remove trailing spaces and tabs

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