Changeset 11817

Show
Ignore:
Timestamp:
10/06/10 16:44:52 (4 years ago)
Author:
robert
Message:

Copied libutil and libtess implementations in form Mesa 7.9/src/glu into the src/osg/glu,
changed extensions from .c to .cpp and got compiling as C files as part of the osg core library.

Updated and cleaned up the rest of the OSG to use the new internal GLU.

Location:
OpenSceneGraph/trunk
Files:
35 added
17 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/CMakeLists.txt

    r11788 r11817  
    304304OPTION(OSG_USE_REF_PTR_IMPLICIT_OUTPUT_CONVERSION "Set to ON to use the ref_ptr<> T* operator() output conversion. " ON) 
    305305 
    306 OPTION(OSG_GLU_AVAILABLE "Set to OFF to disable use of OpenGL GLU library." ${OPENGL_GLU_FOUND}) 
    307306OPTION(OSG_GL1_AVAILABLE "Set to OFF to disable use of OpenGL 1.x functions library." ON) 
    308307OPTION(OSG_GL2_AVAILABLE "Set to OFF to disable use of OpenGL 2.x functions library." ON) 
     
    443442ENDIF(BUILD_OSG_EXAMPLES) 
    444443 
    445  
    446  
    447  
    448  
    449  
    450 # 
    451 # Test to determine if we want the "tripledot" form of the GLU tesselator callback. 
    452 # 
    453 IF(NOT DEFAULT_GLU_TESS_CALLBACK_TRIPLEDOT) 
    454     IF(WIN32 OR CMAKE_SYSTEM_NAME MATCHES "Linux") 
    455  
    456         # Skip the compile check for platforms that never need the variable 
    457         # form. 
    458         SET(DEFAULT_GLU_TESS_CALLBACK_TRIPLEDOT false) 
    459  
    460     ELSE() 
    461  
    462         # For other platforms perform the check 
    463         INCLUDE(CheckCXXSourceCompiles) 
    464         SET(CMAKE_REQUIRED_DEFINITIONS -DGLU_TESS_CALLBACK_TRIPLEDOT) 
    465         SET(CMAKE_REQUIRED_INCLUDES ${CMAKE_CURRENT_SOURCE_DIR}/include ${GLUT_INCLUDE_DIR} ${GL_INCLUDE_DIR}) 
    466         SET(CMAKE_REQUIRED_LIBRARIES ${GLUT_LIBRARY} ${GL_LIBRARY}) 
    467         CHECK_CXX_SOURCE_COMPILES( 
    468             "#include <osg/GL> 
    469             #include <osg/GLU> 
    470             static void testcb(GLvoid *, void*) { } 
    471             int main() { 
    472                GLUtesselator *t = gluNewTess(); 
    473                gluTessCallback(t, GLU_TESS_VERTEX_DATA, (GLU_TESS_CALLBACK) testcb); 
    474                return 0; 
    475             }" 
    476             GLU_Tesselator_Needs_Variable_Parameter_Callback_Convention_Failure_Means_No) 
    477         SET(DEFAULT_GLU_TESS_CALLBACK_TRIPLEDOT 
    478             ${GLU_Tesselator_Needs_Variable_Parameter_Callback_Convention_Failure_Means_No}) 
    479  
    480     ENDIF() 
    481 ENDIF() 
    482  
    483 OPTION(OSG_GLU_TESS_CALLBACK_TRIPLEDOT "Set to ON to build with variable parameter (...) version of GLU tesselator callback" ${DEFAULT_GLU_TESS_CALLBACK_TRIPLEDOT}) 
    484 IF(OSG_GLU_TESS_CALLBACK_TRIPLEDOT) 
    485     ADD_DEFINITIONS(-DGLU_TESS_CALLBACK_TRIPLEDOT) 
    486 ENDIF(OSG_GLU_TESS_CALLBACK_TRIPLEDOT) 
    487444 
    488445# Platform specific: 
  • OpenSceneGraph/trunk/CMakeModules/OsgMacroUtils.cmake

    r11354 r11817  
    5252 
    5353MACRO(LINK_CORELIB_DEFAULT CORELIB_NAME) 
    54     SET(ALL_GL_LIBRARIES ${OPENGL_LIBRARIES}) 
     54    #SET(ALL_GL_LIBRARIES ${OPENGL_LIBRARIES}) 
     55    SET(ALL_GL_LIBRARIES ${OPENGL_gl_LIBRARY}) 
    5556    IF (OSG_GLES1_AVAILABLE OR OSG_GLES2_AVAILABLE) 
    5657        SET(ALL_GL_LIBRARIES ${ALL_GL_LIBRARIES} ${OPENGL_egl_LIBRARY}) 
     
    101102    ENDFOREACH(LINKLIB) 
    102103 
    103     SET(ALL_GL_LIBRARIES ${OPENGL_LIBRARIES}) 
     104    #SET(ALL_GL_LIBRARIES ${OPENGL_LIBRARIES}) 
     105    SET(ALL_GL_LIBRARIES ${OPENGL_gl_LIBRARY}) 
    104106    IF (OSG_GLES1_AVAILABLE OR OSG_GLES2_AVAILABLE) 
    105107        SET(ALL_GL_LIBRARIES ${ALL_GL_LIBRARIES} ${OPENGL_egl_LIBRARY}) 
  • OpenSceneGraph/trunk/examples/CMakeLists.txt

    r11754 r11817  
    158158    ENDIF() 
    159159 
    160     IF(OSG_GLU_AVAILABLE) 
    161         ADD_SUBDIRECTORY(osgphotoalbum) 
    162         ADD_SUBDIRECTORY(osgtessellate) 
    163     ENDIF() 
     160    ADD_SUBDIRECTORY(osgphotoalbum) 
     161    ADD_SUBDIRECTORY(osgtessellate) 
    164162 
    165163    ADD_SUBDIRECTORY(osgpdf) 
  • OpenSceneGraph/trunk/include/osg/GLExtensions

    r9469 r11817  
    151151} 
    152152 
    153  
    154 /** Return true if OpenGL "extension" is supported. 
    155   * Note: Must only be called within a valid OpenGL context, 
    156   * undefined behavior may occur otherwise. 
    157 */ 
    158 extern OSG_EXPORT bool isGLUExtensionSupported(unsigned int contextID, const char *extension); 
    159  
    160  
    161153} 
    162154 
  • OpenSceneGraph/trunk/include/osg/GLU

    r11389 r11817  
    1515#define OSG_GLU 1 
    1616 
    17 #include <osg/Config> 
     17#include <osg/GL> 
    1818 
    19 #ifdef OSG_GLU_AVAILABLE 
     19extern OSG_EXPORT GLint gluScaleImage (GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void *dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid* dataOut); 
     20extern OSG_EXPORT const GLubyte * gluErrorString (GLenum error); 
     21extern OSG_EXPORT GLint gluBuild1DMipmapLevels (GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void *data); 
     22extern OSG_EXPORT GLint gluBuild1DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void *data); 
     23extern OSG_EXPORT GLint gluBuild2DMipmapLevels (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void *data); 
     24extern OSG_EXPORT GLint gluBuild2DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *data); 
     25extern OSG_EXPORT GLint gluBuild3DMipmapLevels (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void *data); 
     26extern OSG_EXPORT GLint gluBuild3DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data); 
    2027 
    21     #include <osg/GL> 
     28/* ErrorCode */ 
     29#define GLU_INVALID_ENUM                   100900 
     30#define GLU_INVALID_VALUE                  100901 
     31#define GLU_OUT_OF_MEMORY                  100902 
     32#define GLU_INCOMPATIBLE_GL_VERSION        100903 
     33#define GLU_INVALID_OPERATION              100904 
    2234 
    23     #if defined(__APPLE__) || \ 
    24         (defined (_AIX) && !defined (_AIX51)) 
    25         #include <OpenGL/glu.h> 
    26     #else 
    27         #include <GL/glu.h> 
    28     #endif 
     35/* Boolean */ 
     36#define GLU_FALSE                          0 
     37#define GLU_TRUE                           1 
    2938 
    30     #if defined(GLU_TESS_CALLBACK_TRIPLEDOT) 
    31         typedef void (GL_APIENTRY *GLU_TESS_CALLBACK)(...); 
    32     #else 
    33         typedef void (GL_APIENTRY *GLU_TESS_CALLBACK)(); 
    34     #endif 
     39/* QuadricDrawStyle */ 
     40#define GLU_POINT                          100010 
     41#define GLU_LINE                           100011 
     42#define GLU_FILL                           100012 
     43#define GLU_SILHOUETTE                     100013 
    3544 
    36 #endif 
     45/* QuadricCallback */ 
     46/*      GLU_ERROR */ 
     47 
     48/* QuadricNormal */ 
     49#define GLU_SMOOTH                         100000 
     50#define GLU_FLAT                           100001 
     51#define GLU_NONE                           100002 
     52 
     53/* QuadricOrientation */ 
     54#define GLU_OUTSIDE                        100020 
     55#define GLU_INSIDE                         100021 
     56 
     57/* TessCallback */ 
     58#define GLU_TESS_BEGIN                     100100 
     59#define GLU_BEGIN                          100100 
     60#define GLU_TESS_VERTEX                    100101 
     61#define GLU_VERTEX                         100101 
     62#define GLU_TESS_END                       100102 
     63#define GLU_END                            100102 
     64#define GLU_TESS_ERROR                     100103 
     65#define GLU_TESS_EDGE_FLAG                 100104 
     66#define GLU_EDGE_FLAG                      100104 
     67#define GLU_TESS_COMBINE                   100105 
     68#define GLU_TESS_BEGIN_DATA                100106 
     69#define GLU_TESS_VERTEX_DATA               100107 
     70#define GLU_TESS_END_DATA                  100108 
     71#define GLU_TESS_ERROR_DATA                100109 
     72#define GLU_TESS_EDGE_FLAG_DATA            100110 
     73#define GLU_TESS_COMBINE_DATA              100111 
     74 
     75/* TessContour */ 
     76#define GLU_CW                             100120 
     77#define GLU_CCW                            100121 
     78#define GLU_INTERIOR                       100122 
     79#define GLU_EXTERIOR                       100123 
     80#define GLU_UNKNOWN                        100124 
     81 
     82/* TessProperty */ 
     83#define GLU_TESS_WINDING_RULE              100140 
     84#define GLU_TESS_BOUNDARY_ONLY             100141 
     85#define GLU_TESS_TOLERANCE                 100142 
     86 
     87/* TessError */ 
     88#define GLU_TESS_ERROR1                    100151 
     89#define GLU_TESS_ERROR2                    100152 
     90#define GLU_TESS_ERROR3                    100153 
     91#define GLU_TESS_ERROR4                    100154 
     92#define GLU_TESS_ERROR5                    100155 
     93#define GLU_TESS_ERROR6                    100156 
     94#define GLU_TESS_ERROR7                    100157 
     95#define GLU_TESS_ERROR8                    100158 
     96#define GLU_TESS_MISSING_BEGIN_POLYGON     100151 
     97#define GLU_TESS_MISSING_BEGIN_CONTOUR     100152 
     98#define GLU_TESS_MISSING_END_POLYGON       100153 
     99#define GLU_TESS_MISSING_END_CONTOUR       100154 
     100#define GLU_TESS_COORD_TOO_LARGE           100155 
     101#define GLU_TESS_NEED_COMBINE_CALLBACK     100156 
     102 
     103/* TessWinding */ 
     104#define GLU_TESS_WINDING_ODD               100130 
     105#define GLU_TESS_WINDING_NONZERO           100131 
     106#define GLU_TESS_WINDING_POSITIVE          100132 
     107#define GLU_TESS_WINDING_NEGATIVE          100133 
     108#define GLU_TESS_WINDING_ABS_GEQ_TWO       100134 
     109 
     110class GLUtesselator; 
     111typedef GLUtesselator GLUtesselatorObj; 
     112typedef GLUtesselator GLUtriangulatorObj; 
     113 
     114#define GLU_TESS_MAX_COORD 1.0e150 
     115 
     116/* Internal convenience typedefs */ 
     117typedef void (GL_APIENTRY * _GLUfuncptr)(); 
     118typedef void (GL_APIENTRY * GLU_TESS_CALLBACK)(); 
     119 
     120extern OSG_EXPORT GLUtesselator* gluNewTess (void); 
     121extern OSG_EXPORT void gluDeleteTess (GLUtesselator* tess); 
     122 
     123extern OSG_EXPORT void gluTessBeginContour (GLUtesselator* tess); 
     124extern OSG_EXPORT void gluTessBeginPolygon (GLUtesselator* tess, GLvoid* data); 
     125extern OSG_EXPORT void gluTessCallback (GLUtesselator* tess, GLenum which, _GLUfuncptr CallBackFunc); 
     126extern OSG_EXPORT void gluTessEndContour (GLUtesselator* tess); 
     127extern OSG_EXPORT void gluTessEndPolygon (GLUtesselator* tess); 
     128extern OSG_EXPORT void gluTessNormal (GLUtesselator* tess, GLdouble valueX, GLdouble valueY, GLdouble valueZ); 
     129extern OSG_EXPORT void gluTessProperty (GLUtesselator* tess, GLenum which, GLdouble data); 
     130extern OSG_EXPORT void gluTessVertex (GLUtesselator* tess, GLdouble *location, GLvoid* data); 
     131 
    37132 
    38133#endif  // __osgGLU_h 
  • OpenSceneGraph/trunk/include/osgUtil/SceneGraphBuilder

    r10613 r11817  
    2121 
    2222#include <osgUtil/Export> 
    23  
    24 #ifndef OSG_GLU_AVAILABLE 
    25     // as we have no GLU we'll just define the required enum values 
    26     #define GLU_FALSE           0 
    27     #define GLU_FILL            100012 
    28     #define GLU_SMOOTH          100000 
    29     #define GLU_OUTSIDE         100020 
    30     #define GLU_NONE            100002 
    31     #define GLU_POINT           100010 
    32     #define GLU_LINE            100011 
    33     #define GLU_FILL            100012 
    34     #define GLU_SILHOUETTE      100013 
    35 #endif 
    3623 
    3724namespace osgUtil { 
  • OpenSceneGraph/trunk/include/osgUtil/Tessellator

    r10613 r11817  
    2626    /* Win32 calling conventions. (or a least thats what the GLUT example tess.c uses.)*/ 
    2727    #define CALLBACK 
    28 #endif 
    29  
    30 #ifndef OSG_GLU_AVAILABLE 
    31     #define GLU_TESS_WINDING_ODD                100130 
    32     #define GLU_TESS_WINDING_NONZERO            100131 
    33     #define GLU_TESS_WINDING_POSITIVE           100132 
    34     #define GLU_TESS_WINDING_NEGATIVE           100133 
    35     #define GLU_TESS_WINDING_ABS_GEQ_TWO        100134 
    3628#endif 
    3729 
     
    219211        typedef std::vector<Vec3d*> Vec3dList; 
    220212 
    221 #ifdef OSG_GLU_AVAILABLE 
    222213        GLUtesselator*  _tobj; 
    223 #else 
    224         void*           _tobj; 
    225 #endif 
     214 
    226215        PrimList        _primList; 
    227216        Vec3dList       _coordData; 
  • OpenSceneGraph/trunk/src/osg/CMakeLists.txt

    r11654 r11817  
    338338    View.cpp 
    339339    Viewport.cpp 
     340 
     341    glu/libutil/gluos.h 
     342    glu/libutil/error.cpp 
     343    glu/libutil/mipmap.cpp 
     344 
     345    glu/libtess/gluos.h 
     346    glu/libtess/normal.cpp 
     347    glu/libtess/memalloc.cpp 
     348    glu/libtess/dict-list.h 
     349    glu/libtess/alg-outline 
     350    glu/libtess/priorityq.cpp 
     351    glu/libtess/normal.h 
     352    glu/libtess/dict.h 
     353    glu/libtess/render.cpp 
     354    glu/libtess/tessmono.h 
     355    glu/libtess/mesh.cpp 
     356    glu/libtess/render.h 
     357    glu/libtess/tessmono.cpp 
     358    glu/libtess/priorityq.h 
     359    glu/libtess/sweep.h 
     360    glu/libtess/priorityq-sort.h 
     361    glu/libtess/sweep.cpp 
     362    glu/libtess/tess.h 
     363    glu/libtess/geom.h 
     364    glu/libtess/memalloc.h 
     365    glu/libtess/dict.cpp 
     366    glu/libtess/priorityq-heap.h 
     367    glu/libtess/geom.cpp 
     368    glu/libtess/tess.cpp 
     369    glu/libtess/mesh.h 
     370 
     371 
    340372    ${OPENSCENEGRAPH_VERSIONINFO_RC} 
    341373) 
  • OpenSceneGraph/trunk/src/osg/Config.in

    r11389 r11817  
    3333#cmakedefine OSG_DISABLE_MSVC_WARNINGS 
    3434 
    35 #cmakedefine OSG_GLU_AVAILABLE 
    3635#cmakedefine OSG_GL1_AVAILABLE 
    3736#cmakedefine OSG_GL2_AVAILABLE 
  • OpenSceneGraph/trunk/src/osg/GLExtensions.cpp

    r11472 r11817  
    1313#include <osg/GLExtensions> 
    1414#include <osg/GL> 
    15 #include <osg/GLU> 
    1615#include <osg/Notify> 
    1716#include <osg/Math> 
     
    304303} 
    305304 
    306 #ifdef OSG_GLU_AVAILABLE 
    307     bool osg::isGLUExtensionSupported(unsigned int contextID, const char *extension) 
    308     { 
    309         ExtensionSet& extensionSet = s_gluExtensionSetList[contextID]; 
    310         std::string& rendererString = s_gluRendererList[contextID]; 
    311  
    312         // if not already set up, initialize all the per graphic context values. 
    313         if (!s_gluInitializedList[contextID]) 
    314         { 
    315             s_gluInitializedList[contextID] = 1; 
    316  
    317             // set up the renderer 
    318             const GLubyte* renderer = glGetString(GL_RENDERER); 
    319             rendererString = renderer ? (const char*)renderer : ""; 
    320  
    321             // get the extension list from OpenGL. 
    322             const char* extensions = (const char*)gluGetString(GLU_EXTENSIONS); 
    323             if (extensions==NULL) return false; 
    324  
    325             // insert the ' ' delimiated extensions words into the extensionSet. 
    326             const char *startOfWord = extensions; 
    327             const char *endOfWord; 
    328             while ((endOfWord = strchr(startOfWord,' '))!=NULL) 
    329             { 
    330                 extensionSet.insert(std::string(startOfWord,endOfWord)); 
    331                 startOfWord = endOfWord+1; 
    332             } 
    333             if (*startOfWord!=0) extensionSet.insert(std::string(startOfWord)); 
    334  
    335             OSG_NOTIFY(INFO)<<"OpenGL extensions supported by installed OpenGL drivers are:"<<std::endl; 
    336             for(ExtensionSet::iterator itr=extensionSet.begin(); 
    337                 itr!=extensionSet.end(); 
    338                 ++itr) 
    339             { 
    340                 OSG_NOTIFY(INFO)<<"    "<<*itr<<std::endl; 
    341             } 
    342  
    343         } 
    344  
    345         // true if extension found in extensionSet. 
    346         bool result = extensionSet.find(extension)!=extensionSet.end(); 
    347  
    348         if (result) 
    349         { 
    350             OSG_NOTIFY(INFO)<<"OpenGL utility library extension '"<<extension<<"' is supported."<<std::endl; 
    351         } 
    352         else 
    353         { 
    354             OSG_NOTIFY(INFO)<<"OpenGL utility library extension '"<<extension<<"' is not supported."<<std::endl; 
    355         } 
    356  
    357         return result; 
    358     } 
    359 #else 
    360     bool osg::isGLUExtensionSupported(unsigned int, const char *) 
    361     { 
    362         return false; 
    363     } 
    364 #endif 
    365305 
    366306#ifdef OSG_GL_LIBRARY_STATIC 
  • OpenSceneGraph/trunk/src/osg/Image.cpp

    r11753 r11817  
    912912void Image::scaleImage(int s,int t,int r, GLenum newDataType) 
    913913{ 
    914 #ifdef OSG_GLU_AVAILABLE 
    915914    if (_s==s && _t==t && _r==r) return; 
    916915 
     
    926925        return; 
    927926    } 
    928  
    929  
    930927 
    931928    unsigned int newTotalSize = computeRowWidthInBytes(s,_pixelFormat,newDataType,_packing)*t; 
     
    970967 
    971968    dirty(); 
    972 #else 
    973     OSG_NOTICE<<"Warning: Image::scaleImage(int s,int t,int r, GLenum newDataType) not supported."<<std::endl; 
    974 #endif 
    975969} 
    976970 
    977971void Image::copySubImage(int s_offset, int t_offset, int r_offset, const osg::Image* source) 
    978972{ 
    979 #ifdef OSG_GLU_AVAILABLE 
    980973    if (!source) return; 
    981974    if (s_offset<0 || t_offset<0 || r_offset<0) 
     
    10291022        OSG_WARN << "Error Image::scaleImage() did not succeed : errorString = "<< gluErrorString((GLenum)status) << ". The rendering context may be invalid." << std::endl; 
    10301023    } 
    1031 #else 
    1032     OSG_NOTICE<<"Warning: Image::copySubImage(int, int, int, const osg::Image*)) not supported."<<std::endl; 
    1033 #endif 
    10341024} 
    10351025 
  • OpenSceneGraph/trunk/src/osg/State.cpp

    r11674 r11817  
    11371137    if (errorNo!=GL_NO_ERROR) 
    11381138    { 
    1139 #ifdef OSG_GLU_AVAILABLE 
    11401139        const char* error = (char*)gluErrorString(errorNo); 
    11411140        if (error) 
     
    11471146            OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error number 0x" << std::hex << errorNo << std::dec; 
    11481147        } 
    1149 #else 
    1150             switch(errorNo) 
    1151             { 
    1152                 case(GL_INVALID_ENUM): 
    1153                     OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error GL_INVALID_ENUM"; 
    1154                     break; 
    1155                 case(GL_INVALID_VALUE): 
    1156                     OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error GL_INVALID_VALUE"; 
    1157                     break; 
    1158                 case(GL_INVALID_OPERATION): 
    1159                     OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error GL_INVALID_OPERATION"; 
    1160                     break; 
    1161                 case(GL_OUT_OF_MEMORY): 
    1162                     OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error GL_OUT_OF_MEMORY"; 
    1163                     break; 
    1164                 default: 
    1165                     OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error number 0x" << std::hex << errorNo << std::dec; 
    1166                     break; 
    1167             } 
    1168 #endif 
     1148 
    11691149        if (str) 
    11701150        { 
     
    11861166    if (errorNo!=GL_NO_ERROR) 
    11871167    { 
    1188         #ifdef OSG_GLU_AVAILABLE 
    1189             const char* error = (char*)gluErrorString(errorNo); 
    1190             if (error) 
    1191             { 
    1192                 OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error '"<< error <<"' after applying GLMode 0x"<<hex<<mode<<dec<< std::endl; 
    1193             } 
    1194             else 
    1195             { 
    1196                 OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error number 0x"<< std::hex << errorNo <<" after applying GLMode 0x"<<hex<<mode<<dec<< std::endl; 
    1197             } 
    1198         #else 
    1199             switch(errorNo) 
    1200             { 
    1201                 case(GL_INVALID_ENUM): 
    1202                     OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error GL_INVALID_ENUM after applying GLMode 0x"<<hex<<mode<<dec<< std::endl; 
    1203                     break; 
    1204                 case(GL_INVALID_VALUE): 
    1205                     OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error GL_INVALID_VALUE after applying GLMode 0x"<<hex<<mode<<dec<< std::endl; 
    1206                     break; 
    1207                 case(GL_INVALID_OPERATION): 
    1208                     OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error GL_INVALID_OPERATION after applying GLMode 0x"<<hex<<mode<<dec<< std::endl; 
    1209                     break; 
    1210                 case(GL_OUT_OF_MEMORY): 
    1211                     OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error GL_OUT_OF_MEMORY after applying GLMode 0x"<<hex<<mode<<dec<< std::endl; 
    1212                     break; 
    1213                 default: 
    1214                     OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error number 0x"<< std::hex << errorNo <<" after applying GLMode 0x"<<hex<<mode<<dec<< std::endl; 
    1215                     break; 
    1216             } 
    1217         #endif 
     1168        const char* error = (char*)gluErrorString(errorNo); 
     1169        if (error) 
     1170        { 
     1171            OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error '"<< error <<"' after applying GLMode 0x"<<hex<<mode<<dec<< std::endl; 
     1172        } 
     1173        else 
     1174        { 
     1175            OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error number 0x"<< std::hex << errorNo <<" after applying GLMode 0x"<<hex<<mode<<dec<< std::endl; 
     1176        } 
    12181177        return true; 
    12191178    } 
     
    12261185    if (errorNo!=GL_NO_ERROR) 
    12271186    { 
    1228         #ifdef OSG_GLU_AVAILABLE 
    1229             const char* error = (char*)gluErrorString(errorNo); 
    1230             if (error) 
    1231             { 
    1232                 OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error '"<< error <<"' after applying attribute "<<attribute->className()<<" "<<attribute<< std::endl; 
    1233             } 
    1234             else 
    1235             { 
    1236                 OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error number 0x"<< std::hex << errorNo <<" after applying attribute "<<attribute->className()<<" "<<attribute<< std::dec << std::endl; 
    1237             } 
    1238         #else 
    1239             switch(errorNo) 
    1240             { 
    1241                 case(GL_INVALID_ENUM): 
    1242                     OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error GL_INVALID_ENUM after applying attribute "<<attribute->className()<<" "<<attribute<< std::dec << std::endl; 
    1243                     break; 
    1244                 case(GL_INVALID_VALUE): 
    1245                     OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error GL_INVALID_VALUE after applying attribute "<<attribute->className()<<" "<<attribute<< std::dec << std::endl; 
    1246                     break; 
    1247                 case(GL_INVALID_OPERATION): 
    1248                     OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error GL_INVALID_OPERATION after applying attribute "<<attribute->className()<<" "<<attribute<< std::dec << std::endl; 
    1249                     break; 
    1250                 case(GL_OUT_OF_MEMORY): 
    1251                     OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error GL_OUT_OF_MEMORY after applying attribute "<<attribute->className()<<" "<<attribute<< std::dec << std::endl; 
    1252                     break; 
    1253                 default: 
    1254                     OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error number 0x"<< std::hex << errorNo <<" after applying attribute "<<attribute->className()<<" "<<attribute<< std::dec << std::endl; 
    1255                     break; 
    1256             } 
    1257         #endif 
     1187        const char* error = (char*)gluErrorString(errorNo); 
     1188        if (error) 
     1189        { 
     1190            OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error '"<< error <<"' after applying attribute "<<attribute->className()<<" "<<attribute<< std::endl; 
     1191        } 
     1192        else 
     1193        { 
     1194            OSG_NOTIFY(WARN)<<"Warning: detected OpenGL error number 0x"<< std::hex << errorNo <<" after applying attribute "<<attribute->className()<<" "<<attribute<< std::dec << std::endl; 
     1195        } 
    12581196 
    12591197        return true; 
  • OpenSceneGraph/trunk/src/osg/Texture.cpp

    r11753 r11817  
    16271627    if (needImageRescale) 
    16281628    { 
    1629 #ifdef OSG_GLU_AVAILABLE 
    16301629        // resize the image to power of two. 
    16311630         
     
    16591658                      inwidth,inheight,image->getDataType(), 
    16601659                      dataPtr); 
    1661 #else 
    1662         OSG_NOTICE<<"Warning: gluScaleImage(..) not supported, cannot subload image."<<std::endl; 
    1663         return; 
    1664 #endif 
    1665     }     
     1660    } 
    16661661 
    16671662    bool mipmappingRequired = _min_filter != LINEAR && _min_filter != NEAREST; 
     
    17711766        else 
    17721767        { 
    1773          
    17741768            if ( !compressed_image) 
    17751769            { 
    17761770                numMipmapLevels = 0; 
    1777 #ifdef OSG_GLU_AVAILABLE 
     1771 
    17781772                gluBuild2DMipmaps( target, _internalFormat, 
    17791773                    inwidth,inheight, 
     
    17881782                    height >>= 1; 
    17891783                } 
    1790 #else 
    1791                 OSG_NOTICE<<"Warning:: gluBuild2DMipMaps(..) not supported."<<std::endl; 
    1792 #endif 
    17931784            } 
    17941785            else  
     
    18751866    if (needImageRescale) 
    18761867    { 
    1877 #ifdef OSG_GLU_AVAILABLE 
    18781868        // resize the image to power of two. 
    18791869        if (image->isMipmap()) 
     
    19061896                      inwidth,inheight,image->getDataType(), 
    19071897                      dataPtr); 
    1908 #else 
    1909         OSG_NOTICE<<"Warning: gluScaleImage(..) not supported, cannot subload image."<<std::endl; 
    1910         return; 
    1911 #endif 
    19121898    } 
    19131899 
  • OpenSceneGraph/trunk/src/osg/Texture1D.cpp

    r11808 r11817  
    323323            numMipmapLevels = 1; 
    324324 
    325 #ifdef OSG_GLU_AVAILABLE 
    326325            gluBuild1DMipmaps( target, _internalFormat, 
    327326                image->s(), 
    328327                (GLenum)image->getPixelFormat(), (GLenum)image->getDataType(), 
    329328                image->data() ); 
    330 #else 
    331             OSG_NOTICE<<"Warning: gluBuild1DMipmaps(..) not supported."<<std::endl; 
    332 #endif 
    333329 
    334330        } 
  • OpenSceneGraph/trunk/src/osgPlugins/CMakeLists.txt

    r11787 r11817  
    155155ENDIF() 
    156156 
    157 IF(OSG_GLU_AVAILABLE) 
    158     ADD_SUBDIRECTORY(lwo) 
    159     ADD_SUBDIRECTORY(dw) 
    160 ENDIF() 
     157ADD_SUBDIRECTORY(lwo) 
     158ADD_SUBDIRECTORY(dw) 
    161159 
    162160ADD_SUBDIRECTORY(bvh) 
  • OpenSceneGraph/trunk/src/osgText/Glyph.cpp

    r11794 r11817  
    435435    if (errorNo!=GL_NO_ERROR) 
    436436    { 
    437 #ifdef OSG_GLU_AVAILABLE 
    438437        const GLubyte* msg = gluErrorString(errorNo); 
    439438        if (msg) { OSG_WARN<<"before Glyph::subload(): detected OpenGL error: "<<msg<<std::endl; } 
    440439        else  { OSG_WARN<<"before Glyph::subload(): detected OpenGL error number: "<<errorNo<<std::endl; } 
    441 #else 
    442         OSG_WARN<<"before Glyph::subload(): detected OpenGL error number: "<<errorNo<<std::endl; 
    443 #endif 
    444440    } 
    445441 
     
    464460 
    465461 
    466 #ifdef OSG_GLU_AVAILABLE 
    467462        const GLubyte* msg = gluErrorString(errorNo); 
    468463        if (msg) { OSG_WARN<<"after Glyph::subload() : detected OpenGL error: "<<msg<<std::endl; } 
    469464        else { OSG_WARN<<"after Glyph::subload() : detected OpenGL error number: "<<errorNo<<std::endl; } 
    470 #else 
    471         OSG_WARN<<"after Glyph::subload() : detected OpenGL error number: "<<errorNo<<std::endl; 
    472 #endif 
    473465 
    474466        OSG_WARN<< "\tglTexSubImage2D(0x"<<hex<<GL_TEXTURE_2D<<dec<<" ,"<<0<<"\t"<<std::endl<< 
  • OpenSceneGraph/trunk/src/osgUtil/Tessellator.cpp

    r11719 r11817  
    2929    _errorCode = 0; 
    3030    _index=0; 
    31  
    32 #ifndef OSG_GLU_AVAILABLE 
    33     OSG_NOTICE<<"Warning: gluTesselation not supported."<<std::endl; 
    34 #endif 
    3531} 
    3632 
     
    4440    reset(); 
    4541 
    46 #ifdef OSG_GLU_AVAILABLE 
    4742    if (!_tobj) _tobj = gluNewTess(); 
    4843     
     
    5550 
    5651    gluTessBeginPolygon(_tobj,this); 
    57 #else 
    58     OSG_NOTICE<<"Warning: gluTesselation not supported."<<std::endl; 
    59 #endif 
    6052}     
    6153     
    6254void Tessellator::beginContour() 
    6355{ 
    64 #ifdef OSG_GLU_AVAILABLE 
    6556    if (_tobj) 
    6657    { 
    6758        gluTessBeginContour(_tobj); 
    6859    } 
    69 #endif 
    7060} 
    7161       
    7262void Tessellator::addVertex(osg::Vec3* vertex) 
    7363{ 
    74 #ifdef OSG_GLU_AVAILABLE 
    7564    if (_tobj) 
    7665    { 
     
    8271        gluTessVertex(_tobj,data->_v,vertex); 
    8372    } 
    84 #endif 
    8573} 
    8674 
    8775void Tessellator::endContour() 
    8876{ 
    89 #ifdef OSG_GLU_AVAILABLE 
    9077    if (_tobj) 
    9178    { 
    9279        gluTessEndContour(_tobj); 
    9380    } 
    94 #endif 
    9581} 
    9682 
    9783void Tessellator::endTessellation() 
    9884{ 
    99 #ifdef OSG_GLU_AVAILABLE 
    10085    if (_tobj) 
    10186    { 
     
    11095        } 
    11196    } 
    112 #endif 
    11397} 
    11498 
    11599void Tessellator::reset() 
    116100{ 
    117 #ifdef OSG_GLU_AVAILABLE 
    118101    if (_tobj) 
    119102    { 
     
    121104        _tobj = 0; 
    122105    } 
    123 #endif 
    124106 
    125107    for (Vec3dList::iterator i = _coordData.begin(); i != _coordData.end(); ++i) 
     
    185167void Tessellator::retessellatePolygons(osg::Geometry &geom) 
    186168{ 
    187 #ifdef OSG_GLU_AVAILABLE 
    188169    // turn the contour list into primitives, a little like Tessellator does but more generally 
    189170    osg::Vec3Array* vertices = dynamic_cast<osg::Vec3Array*>(geom.getVertexArray()); 
     
    304285        collectTessellation(geom, 0);     
    305286    } 
    306 #endif 
    307287} 
    308288