osgDB/Registry

Go to the documentation of this file.

/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * OpenSceneGraph Public License for more details.
*/
 
#ifndef OSGDB_REGISTRY
#define OSGDB_REGISTRY 1
 
#include <OpenThreads/ReentrantMutex>
 
#include <osg/ref_ptr>
#include <osg/ArgumentParser>
#include <osg/KdTree>
 
#include <osgDB/DynamicLibrary>
#include <osgDB/ReaderWriter>
#include <osgDB/Options>
#include <osgDB/DotOsgWrapper>
#include <osgDB/ObjectWrapper>
#include <osgDB/FileCache>
#include <osgDB/ObjectCache>
#include <osgDB/SharedStateManager>
#include <osgDB/ImageProcessor>
 
#include <vector>
#include <map>
#include <string>
 
extern "C"
{
    typedef void (* CPluginFunction) (void);
}
 
namespace osgDB {
 

class OSGDB_EXPORT Registry : public osg::Referenced
{
    public:
 
 
 
 
        static Registry* instance(bool erase = false);

        void readCommandLine(osg::ArgumentParser& commandLine);

        void addFileExtensionAlias(const std::string mapExt, const std::string toExt);

        bool readPluginAliasConfigurationFile( const std::string& file );
 
        typedef std::map< std::string, std::string> MimeTypeExtensionMap;

        void addMimeTypeExtensionMapping(const std::string fromMimeType, const std::string toExt);
        MimeTypeExtensionMap& getMimeTypeExtensionMap() { return _mimeTypeExtMap; }
        const MimeTypeExtensionMap& getMimeTypeExtensionMap() const { return _mimeTypeExtMap; }
 
        void addReaderWriter(ReaderWriter* rw);
        void removeReaderWriter(ReaderWriter* rw);
 
        void addImageProcessor(ImageProcessor* ip);
        void removeImageProcessor(ImageProcessor* ip);

        std::string createLibraryNameForFile(const std::string& fileName);

        std::string createLibraryNameForExtension(const std::string& ext);

        std::string createLibraryNameForNodeKit(const std::string& name);
 
 
        enum LoadStatus {
            NOT_LOADED = 0,
            PREVIOUSLY_LOADED,
            LOADED
        };

        LoadStatus loadLibrary(const std::string& fileName);

        bool closeLibrary(const std::string& fileName);

        void closeAllLibraries();
 
        typedef std::vector< osg::ref_ptr<ReaderWriter> > ReaderWriterList;

        ReaderWriter* getReaderWriterForExtension(const std::string& ext);

        ReaderWriter* getReaderWriterForMimeType(const std::string& mimeType);

        ReaderWriterList& getReaderWriterList() { return _rwList; }

        const ReaderWriterList& getReaderWriterList() const { return _rwList; }

        void getReaderWriterListForProtocol(const std::string& protocol, ReaderWriterList& results) const;
 
        ReaderWriter* getReaderWriterForProtocolAndExtension(const std::string& protocol, const std::string& extension);
 
 
        typedef std::vector< osg::ref_ptr<ImageProcessor> > ImageProcessorList;

        ImageProcessor* getImageProcessor();

        ImageProcessor* getImageProcessorForExtension(const std::string& ext);

        ImageProcessorList& getImageProcessorList() { return _ipList; }

        const ImageProcessorList& getImageProcessorList() const { return _ipList; }
 
 
        typedef class osgDB::FindFileCallback FindFileCallback;
        typedef class osgDB::ReadFileCallback ReadFileCallback;
        typedef class osgDB::WriteFileCallback WriteFileCallback;
        typedef class osgDB::FileLocationCallback FileLocationCallback;

        void setFindFileCallback( FindFileCallback* cb) { _findFileCallback = cb; }

        FindFileCallback* getFindFileCallback() { return _findFileCallback.get(); }

        const FindFileCallback* getFindFileCallback() const { return _findFileCallback.get(); }
 
 
        std::string findDataFile(const std::string& fileName, const Options* options, CaseSensitivity caseSensitivity)
        {
            if (options && options->getFindFileCallback()) return options->getFindFileCallback()->findDataFile(fileName, options, caseSensitivity);
            else if (_findFileCallback.valid()) return _findFileCallback->findDataFile(fileName, options, caseSensitivity);
            else return findDataFileImplementation(fileName, options, caseSensitivity);
        }
        std::string findDataFileImplementation(const std::string& fileName, const Options* options, CaseSensitivity caseSensitivity);
 
        std::string findLibraryFile(const std::string& fileName, const Options* options, CaseSensitivity caseSensitivity)
        {
            if (options && options->getFindFileCallback()) return options->getFindFileCallback()->findLibraryFile(fileName, options, caseSensitivity);
            else if (_findFileCallback.valid()) return _findFileCallback->findLibraryFile(fileName, options, caseSensitivity);
            else return findLibraryFileImplementation(fileName, options, caseSensitivity);
        }
        std::string findLibraryFileImplementation(const std::string& fileName, const Options* options, CaseSensitivity caseSensitivity);
 
 

        void setReadFileCallback( ReadFileCallback* cb) { _readFileCallback = cb; }

        ReadFileCallback* getReadFileCallback() { return _readFileCallback.get(); }

        const ReadFileCallback* getReadFileCallback() const { return _readFileCallback.get(); }
 
 
        ReaderWriter::ReadResult openArchive(const std::string& fileName,ReaderWriter::ArchiveStatus status, unsigned int indexBlockSizeHint, const Options* options)
        {
            if (options && options->getReadFileCallback()) return options->getReadFileCallback()->openArchive(fileName, status, indexBlockSizeHint, options);
            else if (_readFileCallback.valid()) return _readFileCallback->openArchive(fileName, status, indexBlockSizeHint, options);
            else return openArchiveImplementation(fileName, status, indexBlockSizeHint, options);
        }
        ReaderWriter::ReadResult openArchiveImplementation(const std::string& fileName, ReaderWriter::ArchiveStatus status, unsigned int indexBlockSizeHint, const Options* options);
 
        ReaderWriter::ReadResult readObject(const std::string& fileName,const Options* options, bool buildKdTreeIfRequired=true)
        {
            ReaderWriter::ReadResult result;
            if (options && options->getReadFileCallback()) result = options->getReadFileCallback()->readObject(fileName,options);
            else if (_readFileCallback.valid()) result = _readFileCallback->readObject(fileName,options);
            else result = readObjectImplementation(fileName,options);
 
            if (buildKdTreeIfRequired) _buildKdTreeIfRequired(result, options);
 
            return result;
        }
        ReaderWriter::ReadResult readObjectImplementation(const std::string& fileName,const Options* options);
 
        ReaderWriter::ReadResult readImage(const std::string& fileName,const Options* options)
        {
            if (options && options->getReadFileCallback()) return options->getReadFileCallback()->readImage(fileName,options);
            else if (_readFileCallback.valid()) return _readFileCallback->readImage(fileName,options);
            else return readImageImplementation(fileName,options);
        }
        ReaderWriter::ReadResult readImageImplementation(const std::string& fileName,const Options* options);
 
        ReaderWriter::ReadResult readHeightField(const std::string& fileName,const Options* options)
        {
            if (options && options->getReadFileCallback()) return options->getReadFileCallback()->readHeightField(fileName,options);
            else if (_readFileCallback.valid()) return _readFileCallback->readHeightField(fileName,options);
            else return readHeightFieldImplementation(fileName,options);
        }
        ReaderWriter::ReadResult readHeightFieldImplementation(const std::string& fileName,const Options* options);
 
        ReaderWriter::ReadResult readNode(const std::string& fileName,const Options* options, bool buildKdTreeIfRequired=true)
        {
            ReaderWriter::ReadResult result;
            if (options && options->getReadFileCallback()) result = options->getReadFileCallback()->readNode(fileName,options);
            else if (_readFileCallback.valid()) result = _readFileCallback->readNode(fileName,options);
            else result = readNodeImplementation(fileName,options);
 
            if (buildKdTreeIfRequired) _buildKdTreeIfRequired(result, options);
 
            return result;
        }
        ReaderWriter::ReadResult readNodeImplementation(const std::string& fileName,const Options* options);
 
        ReaderWriter::ReadResult readShader(const std::string& fileName,const Options* options)
        {
            if (options && options->getReadFileCallback()) return options->getReadFileCallback()->readShader(fileName,options);
            if (_readFileCallback.valid()) return _readFileCallback->readShader(fileName,options);
            else return readShaderImplementation(fileName,options);
        }
        ReaderWriter::ReadResult readShaderImplementation(const std::string& fileName,const Options* options);
 
        ReaderWriter::ReadResult readScript(const std::string& fileName,const Options* options)
        {
            if (options && options->getReadFileCallback()) return options->getReadFileCallback()->readScript(fileName,options);
            else if (_readFileCallback.valid()) return _readFileCallback->readScript(fileName,options);
            else return readScriptImplementation(fileName,options);
        }
        ReaderWriter::ReadResult readScriptImplementation(const std::string& fileName,const Options* options);
 

        void setWriteFileCallback( WriteFileCallback* cb) { _writeFileCallback = cb; }

        WriteFileCallback* getWriteFileCallback() { return _writeFileCallback.get(); }

        const WriteFileCallback* getWriteFileCallback() const { return _writeFileCallback.get(); }
 
 
        ReaderWriter::WriteResult writeObject(const osg::Object& obj, const std::string& fileName,const Options* options)
        {
            if (options && options->getWriteFileCallback()) return options->getWriteFileCallback()->writeObject(obj,fileName,options);
            else if (_writeFileCallback.valid()) return _writeFileCallback->writeObject(obj,fileName,options);
            else return writeObjectImplementation(obj,fileName,options);
        }
        ReaderWriter::WriteResult writeObjectImplementation(const osg::Object& obj, const std::string& fileName,const Options* options);
 
        ReaderWriter::WriteResult writeImage(const osg::Image& obj, const std::string& fileName,const Options* options)
        {
            if (options && options->getWriteFileCallback()) return options->getWriteFileCallback()->writeImage(obj,fileName,options);
            else if (_writeFileCallback.valid()) return _writeFileCallback->writeImage(obj,fileName,options);
            else return writeImageImplementation(obj,fileName,options);
        }
        ReaderWriter::WriteResult writeImageImplementation(const osg::Image& obj, const std::string& fileName,const Options* options);
 
        ReaderWriter::WriteResult writeHeightField(const osg::HeightField& obj, const std::string& fileName,const Options* options)
        {
            if (options && options->getWriteFileCallback()) return options->getWriteFileCallback()->writeHeightField(obj,fileName,options);
            else if (_writeFileCallback.valid()) return _writeFileCallback->writeHeightField(obj,fileName,options);
            else return writeHeightFieldImplementation(obj,fileName,options);
        }
        ReaderWriter::WriteResult writeHeightFieldImplementation(const osg::HeightField& obj, const std::string& fileName,const Options* options);
 
        ReaderWriter::WriteResult writeNode(const osg::Node& node, const std::string& fileName,const Options* options)
        {
            if (options && options->getWriteFileCallback()) return options->getWriteFileCallback()->writeNode(node,fileName,options);
            else if (_writeFileCallback.valid()) return _writeFileCallback->writeNode(node,fileName,options);
            else return writeNodeImplementation(node,fileName,options);
        }
        ReaderWriter::WriteResult writeNodeImplementation(const osg::Node& node, const std::string& fileName,const Options* options);
 
        ReaderWriter::WriteResult writeShader(const osg::Shader& obj, const std::string& fileName,const Options* options)
        {
            if (options && options->getWriteFileCallback()) return options->getWriteFileCallback()->writeShader(obj,fileName,options);
            else if (_writeFileCallback.valid()) return _writeFileCallback->writeShader(obj,fileName,options);
            else return writeShaderImplementation(obj,fileName,options);
        }
        ReaderWriter::WriteResult writeShaderImplementation(const osg::Shader& obj, const std::string& fileName,const Options* options);
 
        ReaderWriter::WriteResult writeScript(const osg::Script& obj, const std::string& fileName,const Options* options)
        {
            if (options && options->getWriteFileCallback()) return options->getWriteFileCallback()->writeScript(obj,fileName,options);
            else if (_writeFileCallback.valid()) return _writeFileCallback->writeScript(obj,fileName,options);
            else return writeScriptImplementation(obj,fileName,options);
        }
        ReaderWriter::WriteResult writeScriptImplementation(const osg::Script& obj, const std::string& fileName,const Options* options);
 
        inline void _buildKdTreeIfRequired(ReaderWriter::ReadResult& result, const Options* options)
        {
            bool doKdTreeBuilder = (options && options->getBuildKdTreesHint()!=Options::NO_PREFERENCE) ?
                options->getBuildKdTreesHint() == Options::BUILD_KDTREES :
                _buildKdTreesHint == Options::BUILD_KDTREES;
 
            if (doKdTreeBuilder && _kdTreeBuilder.valid() && result.validNode())
            {
                osg::ref_ptr<osg::KdTreeBuilder> builder = _kdTreeBuilder->clone();
                result.getNode()->accept(*builder);
            }
        }

        void setFileLocationCallback( FileLocationCallback* cb) { _fileLocationCallback = cb; }

        FileLocationCallback* getFileLocationCallback() const { return _fileLocationCallback.get(); }
 
 

        void setBuildKdTreesHint(Options::BuildKdTreesHint hint) { _buildKdTreesHint = hint; }

        Options::BuildKdTreesHint getBuildKdTreesHint() const { return _buildKdTreesHint; }

        void setKdTreeBuilder(osg::KdTreeBuilder* builder) { _kdTreeBuilder = builder; }

        osg::KdTreeBuilder* getKdTreeBuilder() { return _kdTreeBuilder.get(); }
 

        void setFileCache(FileCache* fileCache) { _fileCache = fileCache; }

        FileCache* getFileCache() { return _fileCache.get(); }

        const FileCache* getFileCache() const { return _fileCache.get(); }
 

        void setAuthenticationMap(AuthenticationMap* authenticationMap) { _authenticationMap = authenticationMap; }

        AuthenticationMap* getOrCreateAuthenticationMap()
        {
            if (!_authenticationMap) _authenticationMap = new AuthenticationMap;
            return _authenticationMap.get();
        }

        AuthenticationMap* getAuthenticationMap() { return _authenticationMap.get(); }

        const AuthenticationMap* getAuthenticationMap() const { return _authenticationMap.get(); }
 
 
        void setCreateNodeFromImage(bool flag) { _createNodeFromImage = flag; }
        bool getCreateNodeFromImage() const { return _createNodeFromImage; }
 
 
        void setOptions(Options* opt) { _options = opt; }
        Options* getOptions() { return _options.get(); }
        const Options*  getOptions() const { return _options.get(); }
 

        void initFilePathLists() { initDataFilePathList(); initLibraryFilePathList(); }

        void initDataFilePathList();

        void setDataFilePathList(const FilePathList& filepath) { _dataFilePath = filepath; }

        void setDataFilePathList(const std::string& paths);

        FilePathList& getDataFilePathList() { return _dataFilePath; }

        const FilePathList& getDataFilePathList() const { return _dataFilePath; }

        void initLibraryFilePathList();

        void setLibraryFilePathList(const FilePathList& filepath) { _libraryFilePath = filepath; }

        void setLibraryFilePathList(const std::string& paths);

        FilePathList& getLibraryFilePathList() { return _libraryFilePath; }

        const FilePathList& getLibraryFilePathList() const { return _libraryFilePath; }
 
 

        void setObjectCache(ObjectCache* objectCache) { _objectCache = objectCache; }

        ObjectCache* getObjectCache() { return _objectCache.get(); }

        const ObjectCache* getObjectCache() const { return _objectCache.get(); }

        void setExpiryDelay(double expiryDelay) { _expiryDelay = expiryDelay; }
 
        double getExpiryDelay() const { return _expiryDelay; }

        void updateTimeStampOfObjectsInCacheWithExternalReferences(const osg::FrameStamp& frameStamp);

        void removeExpiredObjectsInCache(const osg::FrameStamp& frameStamp);

        void clearObjectCache();

        void addEntryToObjectCache(const std::string& filename, osg::Object* object, double timestamp = 0.0, Options *options = NULL);

        void removeFromObjectCache(const std::string& fileName, Options *options =  NULL);

        osg::Object* getFromObjectCache(const std::string& fileName, Options *options = NULL);

        osg::ref_ptr<osg::Object> getRefFromObjectCache(const std::string& fileName, Options *options = NULL);
 
 

        void addToArchiveCache(const std::string& fileName, osgDB::Archive* archive);

        void removeFromArchiveCache(const std::string& fileName);

        osgDB::Archive* getFromArchiveCache(const std::string& fileName);

        osg::ref_ptr<osgDB::Archive> getRefFromArchiveCache(const std::string& fileName);

        void clearArchiveCache();

        void releaseGLObjects(osg::State* state=0);

        DynamicLibrary*              getLibrary(const std::string& fileName);

        void setSharedStateManager(SharedStateManager* SharedStateManager) { _sharedStateManager = SharedStateManager; }

        SharedStateManager* getOrCreateSharedStateManager();

        SharedStateManager* getSharedStateManager() { return _sharedStateManager.get(); }

        void addArchiveExtension(const std::string ext);

        void registerProtocol(const std::string& protocol);

        bool isProtocolRegistered(const std::string& protocol);

        ObjectWrapperManager* getObjectWrapperManager() { return _objectWrapperManager.get(); }

        DeprecatedDotOsgWrapperManager* getDeprecatedDotOsgObjectWrapperManager() { return _deprecatedDotOsgWrapperManager.get(); }
 
        typedef std::vector< std::string> ArchiveExtensionList;
        const ArchiveExtensionList& getArchiveExtensions() const { return _archiveExtList; }
 
    protected:
 
        virtual ~Registry();
 
        typedef std::vector< osg::ref_ptr<DynamicLibrary> >             DynamicLibraryList;
        typedef std::map< std::string, std::string>                     ExtensionAliasMap;
 
        typedef std::map<std::string, osg::ref_ptr<osgDB::Archive> >    ArchiveCache;
 
        typedef std::set<std::string>                                   RegisteredProtocolsSet;

        Registry();

        DynamicLibraryList::iterator getLibraryItr(const std::string& fileName);
 
        Options::BuildKdTreesHint     _buildKdTreesHint;
        osg::ref_ptr<osg::KdTreeBuilder>            _kdTreeBuilder;
 
        osg::ref_ptr<FileCache>                     _fileCache;
 
        osg::ref_ptr<AuthenticationMap>             _authenticationMap;
 
        bool                                        _createNodeFromImage;
 
        RegisteredProtocolsSet                      _registeredProtocols;
 
    public:
        struct ReadFunctor : public osg::Referenced
        {
            ReadFunctor(const std::string& filename, const Options* options):
                _filename(filename),
                _options(options) {}
 
            virtual ~ReadFunctor() {}
            virtual ReaderWriter::ReadResult doRead(ReaderWriter& rw) const = 0;
            virtual bool isValid(ReaderWriter::ReadResult& readResult) const = 0;
            virtual bool isValid(osg::Object* object) const = 0;
 
            virtual ReadFunctor* cloneType(const std::string& filename, const Options* options) const = 0;
 
            std::string _filename;
            const Options* _options;
        };
 
   protected:
 
        void destruct();
 
        // forward declare helper classes
        struct ReadObjectFunctor;
        struct ReadImageFunctor;
        struct ReadHeightFieldFunctor;
        struct ReadNodeFunctor;
        struct ReadArchiveFunctor;
        struct ReadShaderFunctor;
        struct ReadScriptFunctor;
 
        // make helper classes friends to get round VS6.0 "issues"
        friend struct ReadFunctor;
        friend struct ReadObjectFunctor;
        friend struct ReadImageFunctor;
        friend struct ReadHeightFieldFunctor;
        friend struct ReadNodeFunctor;
        friend struct ReadArchiveFunctor;
        friend struct ReadShaderFunctor;
        friend struct ReadScriptFunctor;
 
        ReaderWriter::ReadResult read(const ReadFunctor& readFunctor);
        ReaderWriter::ReadResult readImplementation(const ReadFunctor& readFunctor,Options::CacheHintOptions cacheHint);
 
 
        // forward declare helper class
        class AvailableReaderWriterIterator;
        friend class AvailableReaderWriterIterator;
        class AvailableArchiveIterator;
        friend class AvailableArchiveIterator;
 
 
        osg::ref_ptr<FindFileCallback>      _findFileCallback;
        osg::ref_ptr<ReadFileCallback>      _readFileCallback;
        osg::ref_ptr<WriteFileCallback>     _writeFileCallback;
        osg::ref_ptr<FileLocationCallback>  _fileLocationCallback;
 
        OpenThreads::ReentrantMutex _pluginMutex;
        ReaderWriterList            _rwList;
        ImageProcessorList          _ipList;
        DynamicLibraryList          _dlList;
 
        OpenThreads::ReentrantMutex _archiveCacheMutex;
        ArchiveCache                _archiveCache;
 
        bool _openingLibrary;
 
        // map to alias to extensions to plugins.
        ExtensionAliasMap  _extAliasMap;
 
        // maps mime-types to extensions.
        MimeTypeExtensionMap _mimeTypeExtMap;
 
        // Utility: Removes whitespace from both ends of a string.
        static std::string trim( const std::string& str );
 
        // options to pass to reader writers.
        osg::ref_ptr<Options>     _options;
 
        FilePathList                            _dataFilePath;
        FilePathList                            _libraryFilePath;
 
        osg::ref_ptr<ObjectCache>               _objectCache;
 
        double                                  _expiryDelay;
 
 
        ArchiveExtensionList                    _archiveExtList;
 
        osg::ref_ptr<SharedStateManager>        _sharedStateManager;
 
        osg::ref_ptr<ObjectWrapperManager>      _objectWrapperManager;
        osg::ref_ptr<DeprecatedDotOsgWrapperManager> _deprecatedDotOsgWrapperManager;
};

inline void readCommandLine(osg::ArgumentParser& parser)
{
    Registry::instance()->readCommandLine(parser);
}

template<class T>
class RegisterReaderWriterProxy
{
    public:
        RegisterReaderWriterProxy()
        {
            if (Registry::instance())
            {
                _rw = new T;
                Registry::instance()->addReaderWriter(_rw.get());
            }
        }
 
        ~RegisterReaderWriterProxy()
        {
            if (Registry::instance())
            {
                Registry::instance()->removeReaderWriter(_rw.get());
            }
        }
 
        T* get() { return _rw.get(); }
 
    protected:
        osg::ref_ptr<T> _rw;
};
 

template<class T>
class RegisterImageProcessorProxy
{
    public:
        RegisterImageProcessorProxy()
        {
            if (Registry::instance())
            {
                _rw = new T;
                Registry::instance()->addImageProcessor(_rw.get());
            }
        }
 
        ~RegisterImageProcessorProxy()
        {
            if (Registry::instance())
            {
                Registry::instance()->removeImageProcessor(_rw.get());
            }
        }
 
        T* get() { return _rw.get(); }
 
    protected:
        osg::ref_ptr<T> _rw;
};
 
struct PluginFunctionProxy
{
    PluginFunctionProxy(CPluginFunction function) { (function)(); }
};
 
#define USE_OSGPLUGIN(ext) \
    extern "C" void osgdb_##ext(void); \
    static osgDB::PluginFunctionProxy proxy_##ext(osgdb_##ext);
 
#define USE_DOTOSGWRAPPER(classname) \
    extern "C" void dotosgwrapper_##classname(void); \
    static osgDB::PluginFunctionProxy proxy_dotosgwrapper_##classname(dotosgwrapper_##classname);
 
#define USE_DOTOSGWRAPPER_LIBRARY(libname) \
    extern "C" void dotosgwrapper_library_##libname(void); \
    static osgDB::PluginFunctionProxy proxy_dotosgwrapper_library_##libname(dotosgwrapper_library_##libname);
 
#define USE_SERIALIZER_WRAPPER(classname) \
    extern "C" void wrapper_serializer_##classname(void); \
    static osgDB::PluginFunctionProxy proxy_serializer_##classname(wrapper_serializer_##classname);
 
#define USE_SERIALIZER_WRAPPER_LIBRARY(libname) \
    extern "C" void wrapper_serializer_library_##libname(void); \
    static osgDB::PluginFunctionProxy proxy_serializer_library_##libname(wrapper_serializer_library_##libname);
 
#define USE_COMPRESSOR_WRAPPER(classname) \
    extern "C" void wrapper_compressor_##classname(void); \
    static osgDB::PluginFunctionProxy proxy_compressor_##classname(wrapper_compressor_##classname);
 
#define REGISTER_OSGPLUGIN(ext, classname) \
    extern "C" void osgdb_##ext(void) {} \
    static osgDB::RegisterReaderWriterProxy<classname> g_proxy_##classname;
 
#define REGISTER_OSGIMAGEPROCESSOR(ext, classname) \
    extern "C" void osgdb_##ext(void) {} \
    static osgDB::RegisterImageProcessorProxy<classname> g_proxy_##classname;
 
}
 
#endif