Changeset 10611

Timestamp:

10/07/09 21:42:32 (4 years ago)

Author:

robert

Message:

Introduced optional build against the GLU library, using optional compile paths to enable/disable GLU related function.

To toggle the use of the GLU library adjust the OSG_GLU_AVAILABLE variable via ccmake . or CMakeSetup.

Location:

OpenSceneGraph/trunk

Files:

• CMakeLists.txt (modified) (1 diff)
• examples/CMakeLists.txt (modified) (3 diffs)
• include/osg/GLU (modified) (1 diff)
• include/osgUtil/SceneGraphBuilder (modified) (1 diff)
• include/osgUtil/Tessellator (modified) (3 diffs)
• src/osg/Config.in (modified) (1 diff)
• src/osg/GLExtensions.cpp (modified) (1 diff)
• src/osg/Image.cpp (modified) (1 diff)
• src/osg/State.cpp (modified) (3 diffs)
• src/osg/Texture.cpp (modified) (7 diffs)
• src/osg/Texture1D.cpp (modified) (1 diff)
• src/osgPlugins/CMakeLists.txt (modified) (1 diff)
• src/osgText/Font.cpp (modified) (2 diffs)
• src/osgUtil/RenderStage.cpp (modified) (1 diff)
• src/osgUtil/Tessellator.cpp (modified) (8 diffs)

OpenSceneGraph/trunk/CMakeLists.txt

@@ -280 +280 @@
 
 OPTION(OSG_USE_REF_PTR_IMPLICIT_OUTPUT_CONVERSION "Set to ON to use the ref_ptr<> T* operator() output conversion. " ON)
+
+OPTION(OSG_GLU_AVAILABLE "Set to OFF to disable use of OpenGL GLU library." ${OPENGL_GLU_FOUND})
+MARK_AS_ADVANCED(OSG_GLU_AVAILABLE)
 
 ################################################################################

OpenSceneGraph/trunk/examples/CMakeLists.txt

@@ -72 +72 @@
     ADD_SUBDIRECTORY(osgparticle)
     ADD_SUBDIRECTORY(osgparticleeffects)
-    ADD_SUBDIRECTORY(osgphotoalbum)
     ADD_SUBDIRECTORY(osgpick)
     ADD_SUBDIRECTORY(osgplanets)
@@ -104 +103 @@
     ADD_SUBDIRECTORY(osgteapot)
     ADD_SUBDIRECTORY(osgterrain)
-    ADD_SUBDIRECTORY(osgtessellate)
     ADD_SUBDIRECTORY(osgtext)
     ADD_SUBDIRECTORY(osgtext3D)
@@ -141 +139 @@
     ADD_SUBDIRECTORY(osgwidgetwindow)
 
+IF(OSG_GLU_AVAILABLE)
+    ADD_SUBDIRECTORY(osgphotoalbum)
+    ADD_SUBDIRECTORY(osgtessellate)
+ENDIF()
+
     ADD_SUBDIRECTORY(osgpdf)
     

OpenSceneGraph/trunk/include/osg/GLU

@@ -15 +15 @@
 #define OSG_GLU 1
 
-#include <osg/GL>
+#include <osg/Config>
 
-#if defined(__APPLE__) || \
-    (defined (_AIX) && !defined (_AIX51))
-    #include <OpenGL/glu.h>
-#else
-    #include <GL/glu.h>
-#endif
+#ifdef OSG_GLU_AVAILABLE
 
-#if defined(GLU_TESS_CALLBACK_TRIPLEDOT)
-    typedef void (APIENTRY *GLU_TESS_CALLBACK)(...);
-#else
-    typedef void (APIENTRY *GLU_TESS_CALLBACK)();
+    #include <osg/GL>
+
+    #if defined(__APPLE__) || \
+        (defined (_AIX) && !defined (_AIX51))
+        #include <OpenGL/glu.h>
+    #else
+        #include <GL/glu.h>
+    #endif
+
+    #if defined(GLU_TESS_CALLBACK_TRIPLEDOT)
+        typedef void (APIENTRY *GLU_TESS_CALLBACK)(...);
+    #else
+        typedef void (APIENTRY *GLU_TESS_CALLBACK)();
+    #endif
+
 #endif
 

OpenSceneGraph/trunk/include/osgUtil/SceneGraphBuilder

@@ -23 +23 @@
 
 namespace osgUtil {
+
+#ifndef OSG_GLU_AVAILABLE
+    // as we have no GLU we'll just define the required enum values
+    #define GLU_FALSE           0
+    #define GLU_FILL            100012
+    #define GLU_SMOOTH          100000
+    #define GLU_OUTSIDE         100020
+    #define GLU_NONE            100002
+    #define GLU_POINT           100010
+    #define GLU_LINE            100011
+    #define GLU_FILL            100012
+    #define GLU_SILHOUETTE      100013
+#endif
 
 /** A class for assisting the building ascene graphs that is equivilant to OpenGL 1.0 style calls.

OpenSceneGraph/trunk/include/osgUtil/Tessellator

@@ -43 +43 @@
 
         /** The winding rule, see red book ch 11. */
+#ifdef OSG_GLU_AVAILABLE
         enum WindingType{
             TESS_WINDING_ODD          = GLU_TESS_WINDING_ODD,
@@ -50 +51 @@
             TESS_WINDING_ABS_GEQ_TWO  =    GLU_TESS_WINDING_ABS_GEQ_TWO
         } ;
-
+#else
+        enum WindingType{
+            TESS_WINDING_ODD,
+            TESS_WINDING_NONZERO,
+            TESS_WINDING_POSITIVE,
+            TESS_WINDING_NEGATIVE,
+            TESS_WINDING_ABS_GEQ_TWO
+        } ;
+#endif
         /** we interpret all contours in the geometry as a single set to be tessellated or
          * each separate drawable's contours needs to be tessellated. */
@@ -212 +221 @@
         typedef std::vector<Vec3d*> Vec3dList;
 
+#ifdef OSG_GLU_AVAILABLE
         GLUtesselator*  _tobj;
+#else
+        void*           _tobj;
+#endif
         PrimList        _primList;
         Vec3dList       _coordData;

OpenSceneGraph/trunk/src/osg/Config.in

@@ -31 +31 @@
 #cmakedefine OSG_USE_UTF8_FILENAME
 #cmakedefine OSG_DISABLE_MSVC_WARNINGS
-
+#cmakedefine OSG_GLU_AVAILABLE
 
 #endif

OpenSceneGraph/trunk/src/osg/GLExtensions.cpp

@@ -236 +236 @@
 }
 
-
-bool osg::isGLUExtensionSupported(unsigned int contextID, const char *extension)
-{
-    ExtensionSet& extensionSet = s_gluExtensionSetList[contextID];
-    std::string& rendererString = s_gluRendererList[contextID];
-
-    // if not already set up, initialize all the per graphic context values.
-    if (!s_gluInitializedList[contextID])
-    {
-        s_gluInitializedList[contextID] = 1;
-    
-        // set up the renderer
-        const GLubyte* renderer = glGetString(GL_RENDERER);
-        rendererString = renderer ? (const char*)renderer : "";
-
-        // get the extension list from OpenGL.
-        const char* extensions = (const char*)gluGetString(GLU_EXTENSIONS);
-        if (extensions==NULL) return false;
-
-        // insert the ' ' delimiated extensions words into the extensionSet.
-        const char *startOfWord = extensions;
-        const char *endOfWord;
-        while ((endOfWord = strchr(startOfWord,' '))!=NULL)
+#ifdef OSG_GLU_AVAILABLE
+    bool osg::isGLUExtensionSupported(unsigned int contextID, const char *extension)
+    {
+        ExtensionSet& extensionSet = s_gluExtensionSetList[contextID];
+        std::string& rendererString = s_gluRendererList[contextID];
+
+        // if not already set up, initialize all the per graphic context values.
+        if (!s_gluInitializedList[contextID])
         {
-            extensionSet.insert(std::string(startOfWord,endOfWord));
-            startOfWord = endOfWord+1;
+            s_gluInitializedList[contextID] = 1;
+
+            // set up the renderer
+            const GLubyte* renderer = glGetString(GL_RENDERER);
+            rendererString = renderer ? (const char*)renderer : "";
+
+            // get the extension list from OpenGL.
+            const char* extensions = (const char*)gluGetString(GLU_EXTENSIONS);
+            if (extensions==NULL) return false;
+
+            // insert the ' ' delimiated extensions words into the extensionSet.
+            const char *startOfWord = extensions;
+            const char *endOfWord;
+            while ((endOfWord = strchr(startOfWord,' '))!=NULL)
+            {
+                extensionSet.insert(std::string(startOfWord,endOfWord));
+                startOfWord = endOfWord+1;
+            }
+            if (*startOfWord!=0) extensionSet.insert(std::string(startOfWord));
+
+            osg::notify(INFO)<<"OpenGL extensions supported by installed OpenGL drivers are:"<<std::endl;
+            for(ExtensionSet::iterator itr=extensionSet.begin();
+                itr!=extensionSet.end();
+                ++itr)
+            {
+                osg::notify(INFO)<<"    "<<*itr<<std::endl;
+            }
+
         }
-        if (*startOfWord!=0) extensionSet.insert(std::string(startOfWord));
-        
-        osg::notify(INFO)<<"OpenGL extensions supported by installed OpenGL drivers are:"<<std::endl;
-        for(ExtensionSet::iterator itr=extensionSet.begin();
-            itr!=extensionSet.end();
-            ++itr)
-        {
-            osg::notify(INFO)<<"    "<<*itr<<std::endl;
-        }
-            
-    }
-
-    // true if extension found in extensionSet.
-    bool result = extensionSet.find(extension)!=extensionSet.end();
-
-    if (result) osg::notify(INFO)<<"OpenGL utility library extension '"<<extension<<"' is supported."<<std::endl;
-    else osg::notify(INFO)<<"OpenGL utility library extension '"<<extension<<"' is not supported."<<std::endl;
-
-    return result;
-}
+
+        // true if extension found in extensionSet.
+        bool result = extensionSet.find(extension)!=extensionSet.end();
+
+        if (result) osg::notify(INFO)<<"OpenGL utility library extension '"<<extension<<"' is supported."<<std::endl;
+        else osg::notify(INFO)<<"OpenGL utility library extension '"<<extension<<"' is not supported."<<std::endl;
+
+        return result;
+    }
+#else
+    bool osg::isGLUExtensionSupported(unsigned int, const char *)
+    {
+        return false;
+    }
+#endif
+
+
 
 #if defined(WIN32)

OpenSceneGraph/trunk/src/osg/Image.cpp

@@ -876 +876 @@
 }
 
-
-void Image::scaleImage(int s,int t,int r, GLenum newDataType)
-{
-    if (_s==s && _t==t && _r==r) return;
-
-    if (_data==NULL)
-    {
-        notify(WARN) << "Error Image::scaleImage() do not succeed : cannot scale NULL image."<<std::endl;
-        return;
-    }
-
-    if (_r!=1 || r!=1)
-    {
-        notify(WARN) << "Error Image::scaleImage() do not succeed : scaling of volumes not implemented."<<std::endl;
-        return;
-    }
-
-    
-
-    unsigned int newTotalSize = computeRowWidthInBytes(s,_pixelFormat,newDataType,_packing)*t;
-
-    // need to sort out what size to really use...
-    unsigned char* newData = new unsigned char [newTotalSize];
-    if (!newData)
-    {
-        // should we throw an exception???  Just return for time being.
-        notify(FATAL) << "Error Image::scaleImage() do not succeed : out of memory."<<newTotalSize<<std::endl;
-        return;
-    }
-
-    glPixelStorei(GL_PACK_ALIGNMENT,_packing);
-    glPixelStorei(GL_UNPACK_ALIGNMENT,_packing);
-
-    GLint status = gluScaleImage(_pixelFormat,
-        _s,
-        _t,
-        _dataType,
-        _data,
-        s,
-        t,
-        newDataType,
-        newData);
-
-    if (status==0)
-    {
-
-        // free old image.
-        _s = s;
-        _t = t;
-        _dataType = newDataType;
-        setData(newData,USE_NEW_DELETE);
-    }
-    else
-    {
-       delete [] newData;
-
-        notify(WARN) << "Error Image::scaleImage() did not succeed : errorString = "<<gluErrorString((GLenum)status)<<std::endl;
-    }
-    
-    dirty();
-}
-
-void Image::copySubImage(int s_offset, int t_offset, int r_offset, const osg::Image* source)
-{
-    if (!source) return;
-    if (s_offset<0 || t_offset<0 || r_offset<0) 
-    {
-        notify(WARN)<<"Warning: negative offsets passed to Image::copySubImage(..) not supported, operation ignored."<<std::endl;
-        return;
-    }
-    
-    if (!_data)
-    {
-        notify(INFO)<<"allocating image"<<endl;
-        allocateImage(s_offset+source->s(),t_offset+source->t(),r_offset+source->r(),
-                    source->getPixelFormat(),source->getDataType(),
-                    source->getPacking());
-    }
-    
-    if (s_offset>=_s || t_offset>=_t  || r_offset>=_r)
-    {
-        notify(WARN)<<"Warning: offsets passed to Image::copySubImage(..) outside destination image, operation ignored."<<std::endl;
-        return;
-    }
-    
-    
-    if (_pixelFormat != source->getPixelFormat())
-    {
-        notify(WARN)<<"Warning: image with an incompatible pixel formats passed to Image::copySubImage(..), operation ignored."<<std::endl;
-        return;
-    }
-
-    void* data_destination = data(s_offset,t_offset,r_offset);
-    
-    glPixelStorei(GL_PACK_ALIGNMENT,source->getPacking());
-    glPixelStorei(GL_PACK_ROW_LENGTH,_s);
-
-    glPixelStorei(GL_UNPACK_ALIGNMENT,_packing);
-    
-    GLint status = gluScaleImage(_pixelFormat,
-        source->s(),
-        source->t(),
-        source->getDataType(),
-        source->data(),
-        source->s(),
-        source->t(),
-        _dataType,
-        data_destination);
-
-    glPixelStorei(GL_PACK_ROW_LENGTH,0);
-
-    if (status!=0)
-    {
-        notify(WARN) << "Error Image::scaleImage() do not succeed : errorString = "<<gluErrorString((GLenum)status)<<std::endl;
-    }
-
-}
-
+#ifdef OSG_GLU_AVAILABLE
+    void Image::scaleImage(int s,int t,int r, GLenum newDataType)
+    {
+        if (_s==s && _t==t && _r==r) return;
+
+        if (_data==NULL)
+        {
+            notify(WARN) << "Error Image::scaleImage() do not succeed : cannot scale NULL image."<<std::endl;
+            return;
+        }
+
+        if (_r!=1 || r!=1)
+        {
+            notify(WARN) << "Error Image::scaleImage() do not succeed : scaling of volumes not implemented."<<std::endl;
+            return;
+        }
+
+
+
+        unsigned int newTotalSize = computeRowWidthInBytes(s,_pixelFormat,newDataType,_packing)*t;
+
+        // need to sort out what size to really use...
+        unsigned char* newData = new unsigned char [newTotalSize];
+        if (!newData)
+        {
+            // should we throw an exception???  Just return for time being.
+            notify(FATAL) << "Error Image::scaleImage() do not succeed : out of memory."<<newTotalSize<<std::endl;
+            return;
+        }
+
+        glPixelStorei(GL_PACK_ALIGNMENT,_packing);
+        glPixelStorei(GL_UNPACK_ALIGNMENT,_packing);
+
+        GLint status = gluScaleImage(_pixelFormat,
+            _s,
+            _t,
+            _dataType,
+            _data,
+            s,
+            t,
+            newDataType,
+            newData);
+
+        if (status==0)
+        {
+
+            // free old image.
+            _s = s;
+            _t = t;
+            _dataType = newDataType;
+            setData(newData,USE_NEW_DELETE);
+        }
+        else
+        {
+        delete [] newData;
+
+            notify(WARN) << "Error Image::scaleImage() did not succeed : errorString = "<<gluErrorString((GLenum)status)<<std::endl;
+        }
+
+        dirty();
+    }
+#else
+    void Image::scaleImage(int,int,int, GLenum)
+    {
+        osg::notify(osg::NOTICE)<<"Warning: Image::scaleImage(int s,int t,int r, GLenum newDataType) not supported."<<std::endl;
+    }
+#endif
+
+#ifdef OSG_GLU_AVAILABLE
+    void Image::copySubImage(int s_offset, int t_offset, int r_offset, const osg::Image* source)
+    {
+        if (!source) return;
+        if (s_offset<0 || t_offset<0 || r_offset<0)
+        {
+            notify(WARN)<<"Warning: negative offsets passed to Image::copySubImage(..) not supported, operation ignored."<<std::endl;
+            return;
+        }
+
+        if (!_data)
+        {
+            notify(INFO)<<"allocating image"<<endl;
+            allocateImage(s_offset+source->s(),t_offset+source->t(),r_offset+source->r(),
+                        source->getPixelFormat(),source->getDataType(),
+                        source->getPacking());
+        }
+
+        if (s_offset>=_s || t_offset>=_t  || r_offset>=_r)
+        {
+            notify(WARN)<<"Warning: offsets passed to Image::copySubImage(..) outside destination image, operation ignored."<<std::endl;
+            return;
+        }
+
+
+        if (_pixelFormat != source->getPixelFormat())
+        {
+            notify(WARN)<<"Warning: image with an incompatible pixel formats passed to Image::copySubImage(..), operation ignored."<<std::endl;
+            return;
+        }
+
+        void* data_destination = data(s_offset,t_offset,r_offset);
+
+        glPixelStorei(GL_PACK_ALIGNMENT,source->getPacking());
+        glPixelStorei(GL_PACK_ROW_LENGTH,_s);
+
+        glPixelStorei(GL_UNPACK_ALIGNMENT,_packing);
+
+        GLint status = gluScaleImage(_pixelFormat,
+            source->s(),
+            source->t(),
+            source->getDataType(),
+            source->data(),
+            source->s(),
+            source->t(),
+            _dataType,
+            data_destination);
+
+        glPixelStorei(GL_PACK_ROW_LENGTH,0);
+
+        if (status!=0)
+        {
+            notify(WARN) << "Error Image::scaleImage() do not succeed : errorString = "<<gluErrorString((GLenum)status)<<std::endl;
+        }
+    }
+#else
+    void Image::copySubImage(int, int, int, const osg::Image*)
+    {
+        osg::notify(osg::NOTICE)<<"Warning: Image::copySubImage(int, int, int, const osg::Image*)) not supported."<<std::endl;
+    }
+#endif
 
 void Image::flipHorizontal()

OpenSceneGraph/trunk/src/osg/State.cpp

@@ -983 +983 @@
     if (errorNo!=GL_NO_ERROR)
     {
+#ifdef OSG_GLU_AVAILABLE
         const char* error = (char*)gluErrorString(errorNo);
         if (error) osg::notify(WARN)<<"Warning: detected OpenGL error '" << error<<"'";
         else       osg::notify(WARN)<<"Warning: detected OpenGL error number 0x" << std::hex << errorNo << std::dec;
-
+#else
+        osg::notify(WARN)<<"Warning: detected OpenGL error number 0x" << std::hex << errorNo << std::dec;
+#endif
         if (str) osg::notify(WARN)<<" at "<<str<< std::endl;
         else     osg::notify(WARN)<<" in osg::State."<< std::endl;
@@ -1000 +1003 @@
     if (errorNo!=GL_NO_ERROR)
     {
+#ifdef OSG_GLU_AVAILABLE
         const char* error = (char*)gluErrorString(errorNo);
         if (error) osg::notify(WARN)<<"Warning: detected OpenGL error '"<< error <<"' after applying GLMode 0x"<<hex<<mode<<dec<< std::endl;
         else       osg::notify(WARN)<<"Warning: detected OpenGL error number 0x"<< std::hex << errorNo <<" after applying GLMode 0x"<<hex<<mode<<dec<< std::endl;
-
+#else
+        osg::notify(WARN)<<"Warning: detected OpenGL error number 0x"<< std::hex << errorNo <<" after applying GLMode 0x"<<hex<<mode<<dec<< std::endl;
+#endif
         return true;
     }
@@ -1014 +1020 @@
     if (errorNo!=GL_NO_ERROR)
     {
+#ifdef OSG_GLU_AVAILABLE
         const char* error = (char*)gluErrorString(errorNo);
         if (error) osg::notify(WARN)<<"Warning: detected OpenGL error '"<< error <<"' after applying attribute "<<attribute->className()<<" "<<attribute<< std::endl;
         else       osg::notify(WARN)<<"Warning: detected OpenGL error number 0x"<< std::hex << errorNo <<" after applying attribute "<<attribute->className()<<" "<<attribute<< std::dec << std::endl;
+#else
+        osg::notify(WARN)<<"Warning: detected OpenGL error number 0x"<< std::hex << errorNo <<" after applying attribute "<<attribute->className()<<" "<<attribute<< std::dec << std::endl;
+#endif
 
         return true;

OpenSceneGraph/trunk/src/osg/Texture.cpp

@@ -1748 +1748 @@
     if (needImageRescale)
     {
-
+#ifdef OSG_GLU_AVAILABLE
         // resize the image to power of two.
         
@@ -1779 +1779 @@
                       image->s(),image->t(),image->getDataType(),image->data(),
                       inwidth,inheight,image->getDataType(),dataPtr);
-
-    }
+#else
+        osg::notify(osg::NOTICE)<<"Warning: gluScaleImage(..) not supported, cannot subload image."<<std::endl;
+        return;
+#endif
+    }    
 
     bool mipmappingRequired = _min_filter != LINEAR && _min_filter != NEAREST;
@@ -1892 +1895 @@
             {
                 numMipmapLevels = 0;
-
+#ifdef OSG_GLU_AVAILABLE
                 gluBuild2DMipmaps( target, _internalFormat,
                     inwidth,inheight,
@@ -1905 +1908 @@
                     height >>= 1;
                 }
+#else
+                osg::notify(osg::NOTICE)<<"Warning:: gluBuild2DMipMaps(..) not supported."<<std::endl;
+#endif
             }
             else 
@@ -1990 +1996 @@
     if (needImageRescale)
     {
-
+#ifdef OSG_GLU_AVAILABLE
         // resize the image to power of two.
-        
         if (image->isMipmap())
         {
@@ -2003 +2008 @@
             return;
         }
-        
+
         unsigned int newTotalSize = osg::Image::computeRowWidthInBytes(inwidth,image->getPixelFormat(),image->getDataType(),image->getPacking())*inheight;
         data = new unsigned char [newTotalSize];
-        
+
         if (!data)
         {
@@ -2021 +2026 @@
                       image->s(),image->t(),image->getDataType(),image->data(),
                       inwidth,inheight,image->getDataType(),data);
+#else
+        osg::notify(osg::NOTICE)<<"Warning: gluScaleImage(..) not supported, cannot subload image."<<std::endl;
+        return;
+#endif
     }
 

OpenSceneGraph/trunk/src/osg/Texture1D.cpp

@@ -300 +300 @@
             numMipmapLevels = 1;
 
+#ifdef OSG_GLU_AVAILABLE
             gluBuild1DMipmaps( target, _internalFormat,
                 image->s(),
                 (GLenum)image->getPixelFormat(), (GLenum)image->getDataType(),
                 image->data() );
+#else
+            osg::notify(osg::NOTICE)<<"Warning: gluBuild1DMipmaps(..) not supported."<<std::endl;
+#endif
 
         }

OpenSceneGraph/trunk/src/osgPlugins/CMakeLists.txt

@@ -158 +158 @@
 ENDIF()
 
-ADD_SUBDIRECTORY(lwo)
+IF(OSG_GLU_AVAILABLE)
+    ADD_SUBDIRECTORY(lwo)
+    ADD_SUBDIRECTORY(dw)
+ENDIF()
+
 ADD_SUBDIRECTORY(bvh)
 ADD_SUBDIRECTORY(x)
-ADD_SUBDIRECTORY(dw)
 ADD_SUBDIRECTORY(ply)
 ADD_SUBDIRECTORY(dxf)

OpenSceneGraph/trunk/src/osgText/Font.cpp

@@ -861 +861 @@
     if (errorNo!=GL_NO_ERROR)
     {
-        osg::notify(osg::WARN)<<"before Font::Glyph::subload(): detected OpenGL error '"<<gluErrorString(errorNo)<<std::endl;
+#ifdef OSG_GLU_AVAILABLE
+        const GLubyte* msg = gluErrorString(errorNo);
+        if (msg) osg::notify(osg::WARN)<<"before Font::Glyph::subload(): detected OpenGL error: "<<msg<<std::endl;
+        else  osg::notify(osg::WARN)<<"before Font::Glyph::subload(): detected OpenGL error number: "<<errorNo<<std::endl;
+#else
+        osg::notify(osg::WARN)<<"before Font::Glyph::subload(): detected OpenGL error number: "<<errorNo<<std::endl;
+#endif
     }
 
@@ -883 +889 @@
     {
 
-        osg::notify(osg::WARN)<<"after Font::Glyph::subload() : detected OpenGL error '"<<gluErrorString(errorNo)<<"'"<<std::endl;
+
+#ifdef OSG_GLU_AVAILABLE
+        const GLubyte* msg = gluErrorString(errorNo);
+        if (msg) osg::notify(osg::WARN)<<"after Font::Glyph::subload() : detected OpenGL error: "<<msg<<std::endl;
+        else osg::notify(osg::WARN)<<"after Font::Glyph::subload() : detected OpenGL error number: "<<errorNo<<std::endl;
+#else
+        osg::notify(osg::WARN)<<"after Font::Glyph::subload() : detected OpenGL error number: "<<errorNo<<std::endl;
+#endif
+
         osg::notify(osg::WARN)<< "\tglTexSubImage2D(0x"<<hex<<GL_TEXTURE_2D<<dec<<" ,"<<0<<"\t"<<std::endl<<
                                  "\t                "<<_texturePosX<<" ,"<<_texturePosY<<std::endl<<

OpenSceneGraph/trunk/src/osgUtil/RenderStage.cpp

@@ -882 +882 @@
         if (errorNo!=GL_NO_ERROR)
         {
+#ifdef OSG_GLU_AVAILABLE
             const char* error = (char*)gluErrorString(errorNo);
             if (error)  osg::notify(osg::NOTICE)<<"Warning: detected OpenGL error '"<<error<<"' after RenderBin::draw(,)"<<std::endl;
             else        osg::notify(osg::NOTICE)<<"Warning: detected OpenGL errorNo= 0x"<<std::hex<<errorNo<<" after RenderBin::draw(,)"<<std::dec<<std::endl;
-
+#else
+            osg::notify(osg::NOTICE)<<"Warning: detected OpenGL errorNo= 0x"<<std::hex<<errorNo<<" after RenderBin::draw(,)"<<std::dec<<std::endl;
+#endif
             if ( fbo_ext )
             {

OpenSceneGraph/trunk/src/osgUtil/Tessellator.cpp

@@ -29 +29 @@
     _errorCode = 0;
     _index=0;
+
+#ifndef OSG_GLU_AVAILABLE
+    osg::notify(osg::NOTICE)<<"Warning: gluTesselation not supported."<<std::endl;
+#endif
 }
 
@@ -40 +44 @@
     reset();
 
+#ifdef OSG_GLU_AVAILABLE
     if (!_tobj) _tobj = gluNewTess();
     
@@ -50 +55 @@
 
     gluTessBeginPolygon(_tobj,this);
+#else
+    osg::notify(osg::NOTICE)<<"Warning: gluTesselation not supported."<<std::endl;
+#endif
 }    
     
 void Tessellator::beginContour()
 {
+#ifdef OSG_GLU_AVAILABLE
     if (_tobj)
     {
         gluTessBeginContour(_tobj);
     }
+#endif
 }
       
 void Tessellator::addVertex(osg::Vec3* vertex)
 {
+#ifdef OSG_GLU_AVAILABLE
     if (_tobj)
     {
@@ -71 +82 @@
         gluTessVertex(_tobj,data->_v,vertex);
     }
+#endif
 }
 
 void Tessellator::endContour()
 {
+#ifdef OSG_GLU_AVAILABLE
     if (_tobj)
     {
         gluTessEndContour(_tobj);
     }
+#endif
 }
 
 void Tessellator::endTessellation()
 {
+#ifdef OSG_GLU_AVAILABLE
     if (_tobj)
     {
@@ -95 +110 @@
         }
     }
+#endif
 }
 
 void Tessellator::reset()
 {
+#ifdef OSG_GLU_AVAILABLE
     if (_tobj)
     {
@@ -104 +121 @@
         _tobj = 0;
     }
+#endif
 
     for (Vec3dList::iterator i = _coordData.begin(); i != _coordData.end(); ++i)
@@ -167 +185 @@
 void Tessellator::retessellatePolygons(osg::Geometry &geom)
 {
+#ifdef OSG_GLU_AVAILABLE
     // turn the contour list into primitives, a little like Tessellator does but more generally
     osg::Vec3Array* vertices = dynamic_cast<osg::Vec3Array*>(geom.getVertexArray());
@@ -285 +304 @@
         collectTessellation(geom, 0);    
     }
+#endif
 }