Merge pull request #802 from eligovision/OpenSceneGraph-3.6_osgtext_fc

OSG_TEXT_USE_FONTCONFIG cmake option added: Set to ON to enable attem…

.gitignore

@@ -6,6 +6,10 @@ doc/openthreads.doxyfile
 
 doc/OpenSceneGraphReferenceDocs/
 doc/OpenThreadsReferenceDocs/
+doc/*.chm
+
+CMakeDoxyfile.in
+CMakeDoxygenDefaults.cmake
 
 cmake_uninstall.cmake
 
@@ -59,6 +63,10 @@ install_manifest*.txt
 *.out
 *.app
 
+# Automatically generated Package files
+packaging/cmake/*
+configure/*
+
 # Platform Specifics - auto generated files
 PlatformSpecifics/Windows/*.rc
 
@@ -79,6 +87,9 @@ PlatformSpecifics/Windows/*.rc
 *.sdf
 *.opensdf
 
+# Visual Studio - Cache/Options Directory
+.vs/
+
 #osx xcode
 DerivedData/
 *.DS_Store

.travis.yml

@@ -15,8 +15,8 @@ matrix:
       dist: trusty
       language: cpp
       env:
-          - CMAKECMD_ARGS="-DBUILD_OSG_EXAMPLES=ON -DBUILD_OSG_PLUGINS_BY_DEFAULT=ON -DBUILD_OSG_APPLICATIONS=ON"
-         # - CMAKECMD_ARGS="-DBUILD_OSG_EXAMPLES=OFF -DBUILD_OSG_PLUGINS_BY_DEFAULT=ON -DBUILD_OSG_APPLICATIONS=ON"
+         # - CMAKECMD_ARGS="-DBUILD_OSG_EXAMPLES=ON -DBUILD_OSG_PLUGINS_BY_DEFAULT=ON -DBUILD_OSG_APPLICATIONS=ON"
+         - CMAKECMD_ARGS="-DBUILD_OSG_EXAMPLES=OFF -DBUILD_OSG_PLUGINS_BY_DEFAULT=ON -DBUILD_OSG_APPLICATIONS=ON"
          #- LLVM_VERSION=3.8
       sudo: false
       cache:

AUTHORS.txt

@@ -1,6 +1,6 @@
-OpenSceneGraph Library 3.6.2
+OpenSceneGraph Library 3.6.4
 
-568 Contributors:
+570 Contributors:
 
 Firstname Surname
 -----------------
@@ -43,8 +43,8 @@ Chris Hanson
 Roland Smeenk
 Roger James
 Jeremy Moles
-J.P. Delport
 Andy Skinner
+J.P. Delport
 Magnus Kessler
 David Fries
 Tom Jolley
@@ -232,6 +232,7 @@ Dietmar Funck
 Colin Cochran
 Christian Ruzicka
 Christian Buchner
+Chris Djali
 Charles Cole
 Blake Williams
 Bj<EFBFBD>rn Hein
@@ -537,9 +538,10 @@ Christophe Herreman
 Christian Noon
 Christian Kaser
 Christian Ehrlicher
+Chris White
 Chris McGlone
-Chris Djali
 Carlos Garcea
+Capostrophic
 Bryce Eldridge
 Bruno Herbelin
 Brian Keener

CMakeLists.txt

@@ -3,13 +3,13 @@
 #
 SET(OPENSCENEGRAPH_MAJOR_VERSION 3)
 SET(OPENSCENEGRAPH_MINOR_VERSION 6)
-SET(OPENSCENEGRAPH_PATCH_VERSION 2)
-SET(OPENSCENEGRAPH_SOVERSION 157)
+SET(OPENSCENEGRAPH_PATCH_VERSION 4)
+SET(OPENSCENEGRAPH_SOVERSION 160)
 
 
 # set to 0 when not a release candidate, non zero means that any generated
 # git tags will be treated as release candidates of given number
-SET(OPENSCENEGRAPH_RELEASE_CANDIDATE 0)
+SET(OPENSCENEGRAPH_RELEASE_CANDIDATE 9)
 set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS TRUE)
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
@@ -41,6 +41,8 @@ IF(APPLE)
     OSG_OSX_VERSION "${OSG_OSX_VERSION}")
 ENDIF()
 
+PROJECT(OpenSceneGraph)
+
 # Set OSX architecture flags here, since they must be specified before
 # creating the actual OSG project.
 # Note that the CMAKE_OSX_* variables are not well documented in
@@ -48,67 +50,73 @@ ENDIF()
 # See https://cmake.org/Bug/view.php?id=14695#c34953
 # Additionally, OSG_WINDOWING_SYSTEM is set here for OSX since its
 # value is needed to find the correct version of OpenGL (X11 or Cocoa).
-IF(APPLE AND NOT ANDROID)
 
-  # Here we check if the user specified IPhone SDK
-  # These options are formally defined later, but can also be specified
-  # by the user at the command line using the cmake -D switch
-  # Note that FORCE is used since the user will likely enable IPhone
-  # build via CMake GUI after already having configured once
-  IF(OSG_BUILD_PLATFORM_IPHONE OR OSG_BUILD_PLATFORM_IPHONE_SIMULATOR)
-    SET(OSG_WINDOWING_SYSTEM "IOS" CACHE STRING "Windowing system type for graphics window creation, options only IOS.")
+IF(ANDROID)
+    SET(OSG_WINDOWING_SYSTEM "None" CACHE STRING "Windowing system type for graphics window creation; options: None.")
+ELSEIF(WIN32 OR MINGW)
+    SET(OSG_WINDOWING_SYSTEM "Win32" CACHE STRING "Windowing system type for graphics window creation; options: Win32 or None.")
+ELSEIF(APPLE)
+    # custom option to flag an iOS build
+    OPTION(OSG_BUILD_PLATFORM_IPHONE "Enable IPhoneSDK Device support" OFF)
 
-    #set iphone arch and flags taken from http://sites.google.com/site/michaelsafyan/coding/resources/how-to-guides/cross-compile-for-the-iphone/how-to-cross-compile-for-the-iphone-using-cmake
     IF(OSG_BUILD_PLATFORM_IPHONE)
-      IF(${IPHONE_VERSION_MIN} LESS "7.0")
-        SET(CMAKE_OSX_ARCHITECTURES "armv6;armv7" CACHE STRING "Build architectures for iOS" FORCE)
-      ELSE()
-        SET(CMAKE_OSX_ARCHITECTURES "armv7;armv7s;arm64" CACHE STRING "Build architectures for iOS" FORCE)
-      ENDIF()
+
+        # set sdk and min versions
+        SET (IPHONE_SDKVER "10.2" CACHE STRING "IOS SDK-Version")
+        SET (IPHONE_VERSION_MIN "7.0" CACHE STRING "IOS minimum os version, use 7.0 or greater to get 64bit support")
+
+        # get full path to sdk from requested versions
+        SET (IPHONE_DEVROOT "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer")
+        SET (IPHONE_SDKROOT "${IPHONE_DEVROOT}/SDKs/iPhoneOS${IPHONE_SDKVER}.sdk")
+
+        # optionally enable bitcode for the build
+        SET (IPHONE_ENABLE_BITCODE "NO" CACHE STRING "IOS Enable Bitcode")
+
+        # seamless toggle between device and simulator
+        SET(CMAKE_XCODE_EFFECTIVE_PLATFORMS "-iphoneos;-iphonesimulator")
+
+        # set deployment target to min version
+        SET(CMAKE_XCODE_ATTRIBUTE_IPHONEOS_DEPLOYMENT_TARGET "${IPHONE_VERSION_MIN}" CACHE STRING "Deployment target for iOS" FORCE)
+
+        # Set standard architectures
+        SET(CMAKE_OSX_ARCHITECTURES "$(ARCHS_STANDARD)")
 
     ELSE()
-      #simulator uses i386 and x86_64 architectures
-      SET(CMAKE_OSX_ARCHITECTURES "i386;x86_64" CACHE STRING "Build architectures for iOS Simulator" FORCE)
-    ENDIF()
+        # OSX >= 10.5 uses Cocoa windowing system, otherwise Carbon
+        IF(OSG_OSX_VERSION VERSION_LESS 10.5)
+            SET(OSG_WINDOWING_SYSTEM "Carbon" CACHE STRING "Windowing system type for graphics window creation; options: Carbon, Cocoa, X11 or None.")
+        ELSE()
+            SET(OSG_WINDOWING_SYSTEM "Cocoa" CACHE STRING "Windowing system type for graphics window creation; options: Carbon, Cocoa, X11 or None.")
+        ENDIF()
 
-    #here we set the specific iphone sdk version. We can only set either device or simulator sdk. So if you want both you currently have to have two separate projects
-    SET(CMAKE_OSX_SYSROOT "${IPHONE_SDKROOT}" CACHE STRING "System root for iOS" FORCE)
-
-  ELSE()
-    # OSX >= 10.5 uses Cocoa windowing system, otherwise Carbon
-    IF(OSG_OSX_VERSION VERSION_LESS 10.5)
-      SET(OSG_WINDOWING_SYSTEM "Carbon" CACHE STRING "Windowing system type for graphics window creation, options Carbon, Cocoa or X11.")
-    ELSE()
-      SET(OSG_WINDOWING_SYSTEM "Cocoa" CACHE STRING "Windowing system type for graphics window creation, options Carbon, Cocoa or X11.")
+        # Set defaults for Universal Binaries. We want 32-bit Intel/PPC on 10.4
+        # and 32/64-bit Intel/PPC on >= 10.5. Anything <= 10.3 doesn't support.
+        # These are set the first time CMake is run, and can be changed by
+        # the user at any time.
+        IF(OSG_OSX_VERSION VERSION_GREATER 10.7)
+            # 64 Bit Works, i386,ppc is not supported any more
+            SET(CMAKE_OSX_ARCHITECTURES "x86_64" CACHE STRING "Build architectures for OSX")
+            SET(CMAKE_OSX_DEPLOYMENT_TARGET "10.8" CACHE STRING "Target OSX version")
+        ELSEIF(OSG_OSX_VERSION VERSION_EQUAL 10.7)
+            # 64 Bit Works, PPC is not supported any more
+            SET(CMAKE_OSX_ARCHITECTURES "i386;x86_64" CACHE STRING "Build architectures for OSX")
+        ELSEIF(OSG_OSX_VERSION VERSION_GREATER 10.4)
+            # 64-bit compiles are not supported with Carbon.
+            SET(CMAKE_OSX_ARCHITECTURES "ppc;i386" CACHE STRING "Build architectures for OSX")
+            SET(CMAKE_OSX_DEPLOYMENT_TARGET "10.5" CACHE STRING "Target OSX version")
+        ELSEIF(OSG_OSX_VERSION VERSION_EQUAL 10.4)
+            # 64-bit compiles are not supported with Carbon.
+            SET(CMAKE_OSX_ARCHITECTURES "ppc;i386" CACHE STRING "Build architectures for OSX")
+        ELSE()
+            # No Universal Binary support and SDK detection is too unreliable.
+            # Warn user and continue at their own peril.
+            MESSAGE(WARNING "OSX 10.3 and earlier not supported.")
+        ENDIF()
     ENDIF()
-
-    # Set defaults for Universal Binaries. We want 32-bit Intel/PPC on 10.4
-    # and 32/64-bit Intel/PPC on >= 10.5. Anything <= 10.3 doesn't support.
-    # These are set the first time CMake is run, and can be changed by
-    # the user at any time.
-    IF(OSG_OSX_VERSION VERSION_GREATER 10.7)
-      # 64 Bit Works, i386,ppc is not supported any more
-      SET(CMAKE_OSX_ARCHITECTURES "x86_64" CACHE STRING "Build architectures for OSX")
-      SET(CMAKE_OSX_DEPLOYMENT_TARGET "10.8" CACHE STRING "Target OSX version")
-    ELSEIF(OSG_OSX_VERSION VERSION_EQUAL 10.7)
-      # 64 Bit Works, PPC is not supported any more
-      SET(CMAKE_OSX_ARCHITECTURES "i386;x86_64" CACHE STRING "Build architectures for OSX")
-    ELSEIF(OSG_OSX_VERSION VERSION_GREATER 10.4)
-      # 64-bit compiles are not supported with Carbon.
-      SET(CMAKE_OSX_ARCHITECTURES "ppc;i386" CACHE STRING "Build architectures for OSX")
-      SET(CMAKE_OSX_DEPLOYMENT_TARGET "10.5" CACHE STRING "Target OSX version")
-    ELSEIF(OSG_OSX_VERSION VERSION_EQUAL 10.4)
-      # 64-bit compiles are not supported with Carbon.
-      SET(CMAKE_OSX_ARCHITECTURES "ppc;i386" CACHE STRING "Build architectures for OSX")
-    ELSE()
-      # No Universal Binary support and SDK detection is too unreliable.
-      # Warn user and continue at their own peril.
-      MESSAGE(WARNING "OSX 10.3 and earlier not supported.")
-    ENDIF()
-  ENDIF()
+ELSE()
+    SET(OSG_WINDOWING_SYSTEM "X11" CACHE STRING "Windowing system type for graphics window creation; options: X11 or None.")
 ENDIF()
 
-PROJECT(OpenSceneGraph)
 
 SET(OPENSCENEGRAPH_VERSION ${OPENSCENEGRAPH_MAJOR_VERSION}.${OPENSCENEGRAPH_MINOR_VERSION}.${OPENSCENEGRAPH_PATCH_VERSION})
 
@@ -218,40 +226,15 @@ ENDIF(OSG_MAINTAINER)
 
 IF(NOT ANDROID)
 IF(APPLE)
-    # Trying to get CMake to generate an XCode IPhone project, current efforts are to get iphoneos sdk 3.1 working
-    # Added option which needs manually setting to select the IPhone SDK for building. We can only have one of the below
-    # set to true. Should really have an OSG_BUILD_PLATFORM variable that we set to our desired platform
-    OPTION(OSG_BUILD_PLATFORM_IPHONE "Enable IPhoneSDK Device support" OFF)
-    OPTION(OSG_BUILD_PLATFORM_IPHONE_SIMULATOR "Enable IPhoneSDK Simulator support" OFF)
 
-    IF(OSG_BUILD_PLATFORM_IPHONE OR OSG_BUILD_PLATFORM_IPHONE_SIMULATOR)
+    IF(OSG_BUILD_PLATFORM_IPHONE)
 
-        #you need to manually set the default sdk version here
-        SET (IPHONE_SDKVER "10.2" CACHE STRING "IOS SDK-Version")
-        SET (IPHONE_VERSION_MIN "7.0" CACHE STRING "IOS minimum os version, use 7.0 or greater to get 64bit support")
+        # set the sdk path as our sysroot, if we set this before the project is defined cmake fails to build its test program
+        SET(CMAKE_OSX_SYSROOT "${IPHONE_SDKROOT}" CACHE STRING "System root for iOS" FORCE)
 
-        #the below is taken from ogre, it states the gcc stuff needs to happen before PROJECT() is called. I've no clue if we even need it
-        # Force gcc <= 4.2 on iPhone
-        IF(IPHONE_VERSION_MIN LESS "6.0")
-            include(CMakeForceCompiler)
-            CMAKE_FORCE_C_COMPILER(llvm-gcc-4.2 GNU)
-            CMAKE_FORCE_CXX_COMPILER(llvm-gcc-4.2 GNU)
-            SET(GCC_THUMB_SUPPORT NO)
-        ENDIF()
+        # Set the path to OpenGL library
+        SET(OPENGL_gl_LIBRARY "${IPHONE_SDKROOT}/System/Library/Frameworks/OpenGLES.framework")
 
-        #set either the device sdk or the simulator sdk. Can't find away to separate these in the same project
-        IF(OSG_BUILD_PLATFORM_IPHONE)
-            SET (IPHONE_DEVROOT "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer")
-            SET (IPHONE_SDKROOT "${IPHONE_DEVROOT}/SDKs/iPhoneOS${IPHONE_SDKVER}.sdk")
-        ELSE()
-            SET (IPHONE_DEVROOT "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer")
-            SET (IPHONE_SDKROOT "${IPHONE_DEVROOT}/SDKs/iPhoneSimulator${IPHONE_SDKVER}.sdk")
-        ENDIF()
-
-        SET (IPHONE_ENABLE_BITCODE "NO" CACHE STRING "IOS Enable Bitcode")
-
-        # Apple iOS: Find OpenGLES
-        FIND_LIBRARY(OPENGLES_LIBRARY OpenGLES)
     ELSE ()
         FIND_LIBRARY(CARBON_LIBRARY Carbon)
         FIND_LIBRARY(COCOA_LIBRARY Cocoa)
@@ -454,6 +437,9 @@ MARK_AS_ADVANCED(OSG_USE_FLOAT_BOUNDINGSPHERE)
 OPTION(OSG_USE_FLOAT_BOUNDINGBOX "Set to ON to build OpenSceneGraph with float BoundingBox instead of double." ON)
 MARK_AS_ADVANCED(OSG_USE_FLOAT_BOUNDINGBOX)
 
+OPTION(OSG_USE_FLOAT_QUAT "Set to ON to build OpenSceneGraph with float Quat instead of double." OFF)
+MARK_AS_ADVANCED(OSG_USE_FLOAT_QUAT)
+
 IF (WIN32)
     OPTION(OSG_USE_UTF8_FILENAME "Set to ON to use a UTF8 locale for filenames instead of the default locale." OFF)
     MARK_AS_ADVANCED(OSG_USE_UTF8_FILENAME)
@@ -515,6 +501,12 @@ ENDIF()
 
 OPTION(OSG_GL_LIBRARY_STATIC "Set to ON to statically link with OpenGL/GLES library." OFF)
 
+IF (OSG_BUILD_PLATFORM_IPHONE OR ANDROID)
+    OPTION(OSG_TEXT_USE_FONTCONFIG "Set to ON to enable attempt to use FontConfig in osgText." OFF)
+ELSE ()
+    OPTION(OSG_TEXT_USE_FONTCONFIG "Set to OFF to disable attempt to use FontConfig in osgText." ON)
+ENDIF ()
+
 # Map the OSG_GL*_AVAILABLE settings to OSG_GL_* settings
 IF (OSG_GLES2_AVAILABLE OR OSG_GLES3_AVAILABLE OR OSG_GL3_AVAILABLE)
     OPTION(OSG_GL_DISPLAYLISTS_AVAILABLE "Set to OFF to disable use of OpenGL display lists." OFF)
@@ -542,12 +534,12 @@ ELSE()
     OPTION(OSG_CPP_EXCEPTIONS_AVAILABLE "Set to OFF to disable compile of OSG components that use C++ exceptions." ON)
 ENDIF()
 
-SET(OSG_GL_CONTEXT_VERSION "1.0" CACHE STRING "GL Context String to pass when creaing graphics contexts")
 
 # Map the OSG_GL*_AVAILABLE settings to OpenGL header settings
+SET(DEFAULT_GL_CONTEXT_VERSION "1.0")
 IF (OSG_GL3_AVAILABLE)
 
-    SET(OSG_GL_CONTEXT_VERSION "3.3")
+    SET(DEFAULT_GL_CONTEXT_VERSION "3.3")
 
     IF (APPLE)
         SET(OPENGL_HEADER1 "#include <OpenGL/gl.h>" CACHE STRING "#include<> line for OpenGL Header")
@@ -600,6 +592,8 @@ ELSE()
     ENDIF()
 ENDIF()
 
+SET(OSG_GL_CONTEXT_VERSION ${DEFAULT_GL_CONTEXT_VERSION} CACHE STRING "GL Context String to pass when creaing graphics contexts")
+
 IF (OSG_GL1_AVAILABLE)
     SET(OSG_GL1_FEATURES 1)
 ELSE()
@@ -752,7 +746,6 @@ ELSE()
     FIND_PACKAGE(COLLADA)
     FIND_PACKAGE(FBX)
     FIND_PACKAGE(ZLIB)
-    FIND_PACKAGE(OpenVRML)
     FIND_PACKAGE(GDAL)
     FIND_PACKAGE(GTA)
     FIND_PACKAGE(CURL)
@@ -798,9 +791,7 @@ IF   (BUILD_OSG_EXAMPLES AND NOT ANDROID)
 
     FIND_PACKAGE(FLTK)
     FIND_PACKAGE(FOX)
-
-    SET(wxWidgets_USE_LIBS base core gl net)
-    FIND_PACKAGE(wxWidgets)
+    FIND_PACKAGE(wxWidgets COMPONENTS base core gl net)
 
 ENDIF(BUILD_OSG_EXAMPLES AND NOT ANDROID)
 
@@ -891,10 +882,26 @@ IF(CYGWIN)
   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -D_DEBUG")
 ENDIF()
 
-IF(UNIX AND NOT WIN32 AND NOT APPLE)
-  IF(CMAKE_SIZEOF_VOID_P MATCHES "8")
-      SET(LIB_POSTFIX "64" CACHE STRING "suffix for 32/64 dir placement")
-      MARK_AS_ADVANCED(LIB_POSTFIX)
+# Set OSG_INSTALL_LIBDIR to specify the installation directories of object code libraries
+IF(DEFINED LIB_POSTFIX)
+  # Use LIB_POSTFIX if defined
+  SET(OSG_INSTALL_LIBDIR lib${LIB_POSTFIX})
+ELSE()
+  IF(CMAKE_VERSION VERSION_LESS "2.8.5")
+    IF(UNIX AND NOT WIN32 AND NOT APPLE)
+      IF(CMAKE_SIZEOF_VOID_P MATCHES "8")
+        SET(LIB_POSTFIX "64" CACHE STRING "suffix for 32/64 dir placement")
+        MARK_AS_ADVANCED(LIB_POSTFIX)
+      ENDIF()
+    ENDIF()
+    IF(NOT DEFINED LIB_POSTFIX)
+      SET(LIB_POSTFIX "")
+    ENDIF()
+    SET(OSG_INSTALL_LIBDIR lib${LIB_POSTFIX})
+  ELSE()
+    # Use the GNU standard installation directories for CMake >= 2.8.5
+    INCLUDE(GNUInstallDirs)
+    SET(OSG_INSTALL_LIBDIR ${CMAKE_INSTALL_LIBDIR})
   ENDIF()
 ENDIF()
 IF(NOT DEFINED LIB_POSTFIX)
@@ -1105,41 +1112,15 @@ ENDIF()
 
 IF(APPLE AND NOT ANDROID)
 
-        #Here we check if the user specified IPhone SDK
-    IF(OSG_BUILD_PLATFORM_IPHONE OR OSG_BUILD_PLATFORM_IPHONE_SIMULATOR)
+    IF(OSG_BUILD_PLATFORM_IPHONE)
 
-        #set iphone arch and flags taken from http://sites.google.com/site/michaelsafyan/coding/resources/how-to-guides/cross-compile-for-the-iphone/how-to-cross-compile-for-the-iphone-using-cmake
-        IF(OSG_BUILD_PLATFORM_IPHONE)
-            IF(${IPHONE_VERSION_MIN} LESS "7.0")
-                SET(CMAKE_OSX_ARCHITECTURES "armv6;armv7" CACHE STRING "Build architectures for iOS" FORCE)
-                SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mno-thumb -pipe -no-cpp-precomp" CACHE STRING "Flags used by the compiler during all build types." FORCE)
-            ELSE()
-                SET(CMAKE_OSX_ARCHITECTURES "armv7;armv7s;arm64" CACHE STRING "Build architectures for iOS" FORCE)
-                SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pipe -no-cpp-precomp" CACHE STRING "Flags used by the compiler during all build types." FORCE)
-            ENDIF()
+        # set osg window system to iOS
+        SET(OSG_WINDOWING_SYSTEM "IOS" CACHE STRING "Windowing system type for graphics window creation, options only IOS." FORCE)
 
-            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -miphoneos-version-min=${IPHONE_VERSION_MIN}" FORCE)
-
-        ELSE()
-            #simulator uses i386 and x86_64 architectures
-            SET(CMAKE_OSX_ARCHITECTURES "i386;x86_64" CACHE STRING "Build architectures for iOS Simulator" FORCE)
-            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mno-thumb -pipe -no-cpp-precomp" CACHE STRING "Flags used by the compiler during all build types." FORCE)
-
-            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mios-simulator-version-min=${IPHONE_VERSION_MIN}" FORCE)
-
-        ENDIF()
-
-        #here we set the specific iphone sdk version. We can only set either device or simulator sdk. So if you want both you currently have to have two separate projects
-        SET(CMAKE_OSX_SYSROOT "${IPHONE_SDKROOT}" CACHE STRING "System root for iOS" FORCE)
-
-        #hack, force link to opengles
-        set(CMAKE_EXE_LINKER_FLAGS "-framework Foundation -framework OpenGLES")
-
-        #use the IPhone windowing system
-        SET(OSG_WINDOWING_SYSTEM "IOS" CACHE STRING "Forced IPhone windowing system on iOS"  FORCE)
+        # set osg default image plugin
         SET(OSG_DEFAULT_IMAGE_PLUGIN_FOR_OSX "imageio" CACHE STRING "Forced imageio default image plugin for iOS" FORCE)
 
-        #I think this or similar will be required for IPhone apps
+        # ensure app bundles for example app
         OPTION(OSG_BUILD_APPLICATION_BUNDLES "Enable the building of applications and examples as OSX Bundles" ON)
 
     ELSE()
@@ -1365,6 +1346,13 @@ IF(NOT OSG_CONFIG_HAS_BEEN_RUN_BEFORE)
     SET(OSG_CONFIG_HAS_BEEN_RUN_BEFORE 1 CACHE INTERNAL "Flag to track whether this is the first time running CMake or if CMake has been configured before")
 ENDIF()
 
+#-----------------------------------------------------------------------------
+# add clobber build target to clear all the non git registered files/directories
+#-----------------------------------------------------------------------------
+add_custom_target(clobber
+    COMMAND git clean -d -f -x
+)
+
 #-----------------------------------------------------------------------------
 ### uninstall target
 #-----------------------------------------------------------------------------
@@ -1376,4 +1364,5 @@ ADD_CUSTOM_TARGET(uninstall
   "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
 
 #
-
+include(FeatureSummary)
+feature_summary(WHAT ALL)

CMakeModules/FindCOLLADA.cmake

@@ -25,11 +25,14 @@ ENDIF()
 
 IF(APPLE)
     SET(COLLADA_BUILDNAME "mac")
-  SET(COLLADA_BOOST_BUILDNAME ${COLLADA_BUILDNAME})
+    SET(COLLADA_BOOST_BUILDNAME ${COLLADA_BUILDNAME})
 ELSEIF(MINGW)
     SET(COLLADA_BUILDNAME "mingw")
-  SET(COLLADA_BOOST_BUILDNAME ${COLLADA_BUILDNAME})
-ELSEIF(MSVC_VERSION EQUAL 1900 OR MSVC_VERSION EQUAL 1910 )
+    SET(COLLADA_BOOST_BUILDNAME ${COLLADA_BUILDNAME})
+ELSEIF((MSVC_VERSION GREATER 1910) OR (MSVC_VERSION EQUAL 1910))
+    SET(COLLADA_BUILDNAME "vc14")
+    SET(COLLADA_BOOST_BUILDNAME "vc141")
+ELSEIF(MSVC_VERSION EQUAL 1900)
     SET(COLLADA_BUILDNAME "vc14")
     SET(COLLADA_BOOST_BUILDNAME "vc140")
 ELSEIF(MSVC_VERSION EQUAL 1800)

CMakeModules/FindFBX.cmake

@@ -60,6 +60,9 @@ SET(FBX_LIBNAME_DEBUG ${FBX_LIBNAME}d)
 
 SET( FBX_SEARCH_PATHS
     $ENV{FBX_DIR}
+    "$ENV{ProgramW6432}/Autodesk/FBX/FBX SDK/2019.0"
+    "$ENV{PROGRAMFILES}/Autodesk/FBX/FBX SDK/2019.0"
+    "/Applications/Autodesk/FBX\ SDK/2019.0"
     "$ENV{ProgramW6432}/Autodesk/FBX/FBX SDK/2018.1.1"
     "$ENV{PROGRAMFILES}/Autodesk/FBX/FBX SDK/2018.1.1"
     "/Applications/Autodesk/FBX\ SDK/2018.0"

CMakeModules/FindFontconfig.cmake

@@ -0,0 +1,101 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindFontconfig
+--------------
+
+Find Fontconfig headers and library.
+
+Imported Targets
+^^^^^^^^^^^^^^^^
+
+``Fontconfig::Fontconfig``
+  The Fontconfig library, if found.
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This will define the following variables in your project:
+
+``FONTCONFIG_FOUND``
+  true if (the requested version of) Fontconfig is available.
+``FONTCONFIG_VERSION``
+  the version of Fontconfig.
+``FONTCONFIG_LIBRARIES``
+  the libraries to link against to use Fontconfig.
+``FONTCONFIG_INCLUDE_DIRS``
+  where to find the Fontconfig headers.
+``FONTCONFIG_COMPILE_OPTIONS``
+  this should be passed to target_compile_options(), if the
+  target is not used for linking
+
+#]=======================================================================]
+
+
+# use pkg-config to get the directories and then use these values
+# in the FIND_PATH() and FIND_LIBRARY() calls
+find_package(PkgConfig QUIET)
+pkg_check_modules(PKG_FONTCONFIG QUIET fontconfig)
+set(FONTCONFIG_COMPILE_OPTIONS ${PKG_FONTCONFIG_CFLAGS_OTHER})
+set(FONTCONFIG_VERSION ${PKG_FONTCONFIG_VERSION})
+
+find_path( FONTCONFIG_INCLUDE_DIR
+  NAMES
+    fontconfig/fontconfig.h
+  HINTS
+    ${PKG_FONTCONFIG_INCLUDE_DIRS}
+    /usr/X11/include
+)
+
+find_library( FONTCONFIG_LIBRARY
+  NAMES
+    fontconfig
+  PATHS
+    ${PKG_FONTCONFIG_LIBRARY_DIRS}
+)
+
+if (FONTCONFIG_INCLUDE_DIR AND NOT FONTCONFIG_VERSION)
+  file(STRINGS ${FONTCONFIG_INCLUDE_DIR}/fontconfig/fontconfig.h _contents REGEX "^#define[ \t]+FC_[A-Z]+[ \t]+[0-9]+$")
+  unset(FONTCONFIG_VERSION)
+  foreach(VPART MAJOR MINOR REVISION)
+    foreach(VLINE ${_contents})
+      if(VLINE MATCHES "^#define[\t ]+FC_${VPART}[\t ]+([0-9]+)$")
+        set(FONTCONFIG_VERSION_PART "${CMAKE_MATCH_1}")
+        if(FONTCONFIG_VERSION)
+          string(APPEND FONTCONFIG_VERSION ".${FONTCONFIG_VERSION_PART}")
+        else()
+          set(FONTCONFIG_VERSION "${FONTCONFIG_VERSION_PART}")
+        endif()
+      endif()
+    endforeach()
+  endforeach()
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Fontconfig
+  FOUND_VAR
+    FONTCONFIG_FOUND
+  REQUIRED_VARS
+    FONTCONFIG_LIBRARY
+    FONTCONFIG_INCLUDE_DIR
+  VERSION_VAR
+    FONTCONFIG_VERSION
+)
+
+
+if(FONTCONFIG_FOUND AND NOT TARGET Fontconfig::Fontconfig)
+  add_library(Fontconfig::Fontconfig UNKNOWN IMPORTED)
+  set_target_properties(Fontconfig::Fontconfig PROPERTIES
+    IMPORTED_LOCATION "${FONTCONFIG_LIBRARY}"
+    INTERFACE_COMPILE_OPTIONS "${FONTCONFIG_COMPILE_OPTIONS}"
+    INTERFACE_INCLUDE_DIRECTORIES "${FONTCONFIG_INCLUDE_DIR}"
+  )
+endif()
+
+mark_as_advanced(FONTCONFIG_LIBRARY FONTCONFIG_INCLUDE_DIR)
+
+if(FONTCONFIG_FOUND)
+  set(FONTCONFIG_LIBRARIES ${FONTCONFIG_LIBRARY})
+  set(FONTCONFIG_INCLUDE_DIRS ${FONTCONFIG_INCLUDE_DIR})
+endif()

CMakeModules/OsgMacroUtils.cmake

@@ -225,7 +225,7 @@ MACRO(SETUP_LIBRARY LIB_NAME)
         )
         SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES FOLDER "OSG Core")
         IF(APPLE)
-            IF(OSG_BUILD_PLATFORM_IPHONE OR OSG_BUILD_PLATFORM_IPHONE_SIMULATOR)
+            IF(OSG_BUILD_PLATFORM_IPHONE)
                 SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES XCODE_ATTRIBUTE_ENABLE_BITCODE ${IPHONE_ENABLE_BITCODE})
             ENDIF()
             SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES XCODE_ATTRIBUTE_WARNING_CFLAGS "")
@@ -336,7 +336,7 @@ MACRO(SETUP_PLUGIN PLUGIN_NAME)
     SET_TARGET_PROPERTIES(${TARGET_TARGETNAME} PROPERTIES FOLDER "Plugins")
     IF(APPLE)
         SET_TARGET_PROPERTIES(${TARGET_TARGETNAME} PROPERTIES XCODE_ATTRIBUTE_WARNING_CFLAGS "")
-        IF(OSG_BUILD_PLATFORM_IPHONE OR OSG_BUILD_PLATFORM_IPHONE_SIMULATOR)
+        IF(OSG_BUILD_PLATFORM_IPHONE)
             SET_TARGET_PROPERTIES(${TARGET_TARGETNAME} PROPERTIES XCODE_ATTRIBUTE_ENABLE_BITCODE ${IPHONE_ENABLE_BITCODE})
         ENDIF()
     ENDIF()
@@ -429,7 +429,7 @@ MACRO(SETUP_EXE IS_COMMANDLINE_APP)
 
     IF(APPLE)
         SET_TARGET_PROPERTIES(${TARGET_TARGETNAME} PROPERTIES XCODE_ATTRIBUTE_WARNING_CFLAGS "")
-        IF(OSG_BUILD_PLATFORM_IPHONE OR OSG_BUILD_PLATFORM_IPHONE_SIMULATOR)
+        IF(OSG_BUILD_PLATFORM_IPHONE)
             SET_TARGET_PROPERTIES(${TARGET_TARGETNAME} PROPERTIES XCODE_ATTRIBUTE_ENABLE_BITCODE ${IPHONE_ENABLE_BITCODE})
         ENDIF()
     ENDIF()

README.md

@@ -25,7 +25,7 @@ If details below are not sufficient then head over to the openscenegraph.org to
 
 Robert Osfield.
 Project Lead.
-29th June 2018.
+25th July 2019.
 
 ---
 
@@ -88,13 +88,14 @@ Many of the example programs use command-line arguments. When double-clicking on
 
 ## Section 3. Release notes on iOS build, by Thomas Hogarth
 
-With CMake, XCode and the iOS sdk installed you can generate an iOS XCode project using the following command line:
+With CMake 3.11, XCode 9.4 and the iOS sdk 11.4 installed you can generate an iOS XCode project using the following command line:
 
-    export THIRDPARTY_PATH=/path/to/my/3rdParty
+    export THIRDPARTY_PATH=/path/to/3rdParty
     cmake ./ -G Xcode -DOSG_BUILD_PLATFORM_IPHONE:BOOL=ON \
-    -DIPHONE_SDKVER="10.2" \
-    -DIPHONE_VERSION_MIN="8.0" \
-    -DOPENGL_PROFILE:STRING=GLES2 \
+    -DIPHONE_SDKVER="11.4" \
+    -DIPHONE_VERSION_MIN="10.0" \
+    -DOPENGL_PROFILE:STRING=GLES3 \
+    -DOSG_CPP_EXCEPTIONS_AVAILABLE:BOOL=ON \
     -DBUILD_OSG_APPLICATIONS:BOOL=OFF \
     -DBUILD_OSG_EXAMPLES:BOOL=ON \
     -DOSG_WINDOWING_SYSTEM:STRING=IOS \
@@ -105,15 +106,15 @@ With CMake, XCode and the iOS sdk installed you can generate an iOS XCode projec
     -DCURL_LIBRARY:PATH="$THIRDPARTY_PATH/curl-ios-device/lib/libcurl.a" \
     -DFREETYPE_INCLUDE_DIR_freetype2:PATH="$THIRDPARTY_PATH/freetype-ios-universal/include/freetype" \
     -DFREETYPE_INCLUDE_DIR_ft2build:PATH="$THIRDPARTY_PATH/freetype-ios-universal/include" \
-    -DFREETYPE_LIBRARY:PATH="$THIRDPARTY_PATH/freetype-ios-universal/lib/libFreeType_iphone_universal.a" \
+    -DFREETYPE_LIBRARY:PATH="$THIRDPARTY_PATH/freetype-ios-universal/lib/libFreetype2.a" \
     -DTIFF_INCLUDE_DIR:PATH="$THIRDPARTY_PATH/tiff-ios-device/include" \
     -DTIFF_LIBRARY:PATH="$THIRDPARTY_PATH/tiff-ios-device/lib/libtiff.a" \
     -DGDAL_INCLUDE_DIR:PATH="$THIRDPARTY_PATH/gdal-ios-device/include" \
     -DGDAL_LIBRARY:PATH="$THIRDPARTY_PATH/gdal-ios-device/lib/libgdal.a"
 
 
-Be sure to set the THIRDPARTY_PATH to the path containing your thirdparty dependencies. Set IPHONE_SDKVER to the version of the iOS sdk you have installed, in this instance 10.2. IPHONE_VERSION_MIN controls the base sdk used by xcode, and lastly set OPENGL_PROFILE to the version of GLES you want to use.
+Be sure to set the THIRDPARTY_PATH to the path containing your thirdparty dependencies. Set IPHONE_SDKVER to the version of the iOS sdk you have installed, in this instance 11.4. IPHONE_VERSION_MIN controls the deployment sdk used by xcode, and lastly set OPENGL_PROFILE to the version of GLES you want to use.
 
-Once this completes an XCode project will have been generated in the osg root folder. Open the generated Xcode project, select the example_osgViewerIPhone target. In 'General' tab set a development team. In the 'Build Settings' tab search for 'Other Linker Flags', then for each target type (debug, release etc) that you want to use open the list of arguments and delete the 'OpenGL' line and the '-framework' line above it. This is because cmake has tried to add the desktop OpenGL library which we don't want.
+Once this completes an XCode project will have been generated in the osg root folder. Open the generated Xcode project, select the example_osgViewerIPhone target. In 'General' tab set a development team.
 
-Once this is done you should be able to build and deploy the `example_osgViewerIPhone` target on your device.
+Once this is done you should be able to build and deploy the `example_osgViewerIPhone` target on your device.

applications/osgconv/osgconv.cpp

@@ -45,6 +45,8 @@ class MyGraphicsContext {
             traits->doubleBuffer = false;
             traits->sharedContext = 0;
             traits->pbuffer = true;
+            traits->readDISPLAY();
+            traits->setUndefinedScreenDetailsToDefaultScreen();
 
             _gc = osg::GraphicsContext::createGraphicsContext(traits.get());
 
@@ -769,7 +771,7 @@ int main( int argc, char **argv )
         osgDB::Registry::instance()->getOptions()->setObjectCacheHint(osgDB::Options::CACHE_ALL);
     }
 
-    std::string fileNameOut("converted.osg");
+    std::string fileNameOut("converted.osgt");
     if (fileNames.size()>1)
     {
         fileNameOut = fileNames.back();
@@ -778,29 +780,66 @@ int main( int argc, char **argv )
 
     osg::Timer_t startTick = osg::Timer::instance()->tick();
 
-    osg::ref_ptr<osg::Node> root = osgDB::readRefNodeFiles(fileNames);
+    typedef std::vector< osg::ref_ptr<osg::Image> > Images;
+    typedef std::vector< osg::ref_ptr<osg::Node> > Nodes;
+    typedef std::vector< osg::ref_ptr<osg::Object> > Objects;
 
-    if (root.valid())
+    Images images;
+    Nodes nodes;
+    Objects objects;
+
+    for(FileNameList::iterator itr = fileNames.begin();
+        itr != fileNames.end();
+        ++itr)
     {
-        osg::Timer_t endTick = osg::Timer::instance()->tick();
-        osg::notify(osg::INFO)<<"Time to load files "<<osg::Timer::instance()->delta_m(startTick, endTick)<<" ms"<<std::endl;
+        osg::ref_ptr<osg::Object> object = osgDB::readObjectFile(*itr);
+        if (object.valid())
+        {
+            if (object->asNode()) nodes.push_back(object->asNode());
+            else if (object->asImage()) images.push_back(object->asImage());
+            else objects.push_back(object);
+        }
+    }
+
+    if (images.empty() && nodes.empty() && objects.empty())
+    {
+        osg::notify(osg::NOTICE)<<"Warning: failed to load any files"<<std::endl;
+        return 1;
     }
 
 
-    if (pruneStateSet)
-    {
-        PruneStateSetVisitor pssv;
-        root->accept(pssv);
-    }
+    osg::Timer_t endTick = osg::Timer::instance()->tick();
+    osg::notify(osg::INFO)<<"Time to load files "<<osg::Timer::instance()->delta_m(startTick, endTick)<<" ms"<<std::endl;
 
-    if (fixTransparencyMode != FixTransparencyVisitor::NO_TRANSPARANCY_FIXING)
+    osg::ref_ptr<osg::Node> root;
+
+    if (nodes.size()==1) root = nodes.front();
+    else if (nodes.size()>1)
     {
-        FixTransparencyVisitor atv(fixTransparencyMode);
-        root->accept(atv);
+        osg::ref_ptr<osg::Group> group = new osg::Group;
+        for(Nodes::iterator itr = nodes.begin();
+            itr != nodes.end();
+            ++itr)
+        {
+            group->addChild(itr->get());
+        }
+
+        root = group;
     }
 
     if ( root.valid() )
     {
+        if (pruneStateSet)
+        {
+            PruneStateSetVisitor pssv;
+            root->accept(pssv);
+        }
+
+        if (fixTransparencyMode != FixTransparencyVisitor::NO_TRANSPARANCY_FIXING)
+        {
+            FixTransparencyVisitor atv(fixTransparencyMode);
+            root->accept(atv);
+        }
 
         if (smooth)
         {
@@ -866,6 +905,20 @@ int main( int argc, char **argv )
             osg::notify(osg::NOTICE)<<result.message()<< std::endl;
         }
     }
+    else if (!images.empty())
+    {
+        if (images.size()>1)
+        {
+            OSG_NOTICE<<"Warning: osgconv does not support writing multiple to a single file."<<std::endl;
+            return 1;
+        }
+
+        osgDB::writeImageFile(*images.front(), fileNameOut);
+    }
+    else if (!objects.empty())
+    {
+        osgDB::writeObjectFile(*images.front(), fileNameOut);
+    }
     else
     {
         osg::notify(osg::NOTICE)<<"Error no data loaded."<< std::endl;

applications/osgversion/osgversion.cpp

@@ -17,6 +17,7 @@
 #include <osg/Plane>
 #include <osg/BoundingBox>
 #include <osg/BoundingSphere>
+#include <osg/Quat>
 
 #ifdef BUILD_CONTRIBUTORS
 extern void printContributors(const std::string& changeLog, bool printNumEntries);
@@ -40,6 +41,7 @@ int main( int argc, char** argv)
     arguments.getApplicationUsage()->addCommandLineOption("Plane::value_type",              "Print the value of Plane::value_type");
     arguments.getApplicationUsage()->addCommandLineOption("BoundingSphere::value_type",     "Print the value of BoundingSphere::value_type");
     arguments.getApplicationUsage()->addCommandLineOption("BoundingBox::value_type",        "Print the value of BoundingBox::value_type");
+    arguments.getApplicationUsage()->addCommandLineOption("Quat::value_type",               "Print the value of Quat::value_type");
 
 #ifdef BUILD_CONTRIBUTORS
     arguments.getApplicationUsage()->addCommandLineOption("-r <file> or --read <file>",     "Read the ChangeLog to generate an estimated contributors list.");
@@ -139,6 +141,12 @@ int main( int argc, char** argv)
         return 0;
     }
 
+    if (arguments.read("Quat::value_type"))
+    {
+        cout << ((sizeof(osg::Quat::value_type) == 4) ? "float" : "double") << endl;
+        return 0;
+    }
+
     cout << osgGetLibraryName() << " " << osgGetVersion() << endl << endl;
 
 #ifdef BUILD_CONTRIBUTORS

applications/osgviewer/osgviewer.cpp

@@ -48,6 +48,7 @@ int main(int argc, char** argv)
     arguments.getApplicationUsage()->addCommandLineOption("-p <filename>","Play specified camera path animation file, previously saved with 'z' key.");
     arguments.getApplicationUsage()->addCommandLineOption("--speed <factor>","Speed factor for animation playing (1 == normal speed).");
     arguments.getApplicationUsage()->addCommandLineOption("--device <device-name>","add named device to the viewer");
+    arguments.getApplicationUsage()->addCommandLineOption("--stats","print out load and compile timing stats");
 
     osgViewer::Viewer viewer(arguments);
 
@@ -71,6 +72,8 @@ int main(int argc, char** argv)
         return 1;
     }
 
+    bool printStats = arguments.read("--stats");
+
     std::string url, username, password;
     while(arguments.read("--login",url, username, password))
     {
@@ -109,7 +112,7 @@ int main(int argc, char** argv)
         while (arguments.read("-p",pathfile))
         {
             osgGA::AnimationPathManipulator* apm = new osgGA::AnimationPathManipulator(pathfile);
-            if (apm || !apm->valid())
+            if (apm && !apm->getAnimationPath()->empty())
             {
                 apm->setTimeScale(animationSpeed);
 
@@ -147,6 +150,8 @@ int main(int argc, char** argv)
     // add the screen capture handler
     viewer.addEventHandler(new osgViewer::ScreenCaptureHandler);
 
+    osg::ElapsedTime elapsedTime;
+
     // load the data
     osg::ref_ptr<osg::Node> loadedModel = osgDB::readRefNodeFiles(arguments);
     if (!loadedModel)
@@ -155,6 +160,15 @@ int main(int argc, char** argv)
         return 1;
     }
 
+    if (printStats)
+    {
+        double loadTime = elapsedTime.elapsedTime_m();
+        std::cout<<"Load time "<<loadTime<<"ms"<<std::endl;
+
+        viewer.getStats()->collectStats("compile", true);
+    }
+
+
     // any option left unread are converted into errors to write out later.
     arguments.reportRemainingOptionsAsUnrecognized();
 

applications/present3D/present3D.cpp

@@ -484,7 +484,7 @@ int main( int argc, char **argv )
         while (arguments.read("-p",pathfile))
         {
             osgGA::AnimationPathManipulator* apm = new osgGA::AnimationPathManipulator(pathfile);
-            if (apm || !apm->valid())
+            if (apm && !apm->getAnimationPath()->empty())
             {
                 unsigned int num = keyswitchManipulator->getNumMatrixManipulators();
                 keyswitchManipulator->addMatrixManipulator( keyForAnimationPath, "Path", apm );

examples/CMakeLists.txt

@@ -243,13 +243,11 @@ ELSE(DYNAMIC_OPENSCENEGRAPH)
     #needed on win32 or the linker get confused by _declspec declarations
     ADD_DEFINITIONS(-DOSG_LIBRARY_STATIC)
 
-    ADD_SUBDIRECTORY(osgstaticviewer)
-
-    # IPHONE_PORT@tom
-    IF(OSG_BUILD_PLATFORM_IPHONE OR OSG_BUILD_PLATFORM_IPHONE_SIMULATOR)
+    IF(OSG_BUILD_PLATFORM_IPHONE)
         ADD_SUBDIRECTORY(osgviewerIPhone)
+    ELSE()
+        ADD_SUBDIRECTORY(osgstaticviewer)
     ENDIF()
-     # IPHONE_PORT@tom
 
 ENDIF(DYNAMIC_OPENSCENEGRAPH)
 

examples/osgCMakeExample/main.cpp

@@ -113,7 +113,7 @@ int main(int argc, char** argv)
         while (arguments.read("-p",pathfile))
         {
             osgGA::AnimationPathManipulator* apm = new osgGA::AnimationPathManipulator(pathfile);
-            if (apm || !apm->valid())
+            if (apm && !apm->getAnimationPath()->empty())
             {
                 apm->setTimeScale(animationSpeed);
 

examples/osgautocapture/osgautocapture.cpp

@@ -249,6 +249,8 @@ int main( int argc, char **argv )
             traits->width = 1 << 12;
             traits->height = 1 << 12;
             traits->pbuffer = true;
+            traits->readDISPLAY();
+            traits->setUndefinedScreenDetailsToDefaultScreen();
         }
         osg::ref_ptr<osg::GraphicsContext> pbuffer = osg::GraphicsContext::createGraphicsContext(traits.get());
         if (pbuffer.valid())

examples/osgautotransform/osgautotransform.cpp

@@ -209,6 +209,8 @@ osgViewer::View* createView(osg::ref_ptr<osg::Node> scenegraph, osg::ref_ptr<osg
         traits->windowDecoration = true;
         traits->doubleBuffer = true;
         traits->sharedContext = 0;
+        traits->readDISPLAY();
+        traits->setUndefinedScreenDetailsToDefaultScreen();
 
         gc = osg::GraphicsContext::createGraphicsContext(traits.get());
         if (!gc)
@@ -267,7 +269,11 @@ int main(int argc, char** argv)
         }
 
         unsigned int width, height;
-        wsi->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(0), width, height);
+        osg::GraphicsContext::ScreenIdentifier main_screen_id;
+
+        main_screen_id.readDISPLAY();
+        main_screen_id.setUndefinedScreenDetailsToDefaultScreen();
+        wsi->getScreenResolution(main_screen_id, width, height);
 
         unsigned int x=0, y=0;
         while(arguments.read("--window", x, y, width, height)) {}
@@ -283,6 +289,8 @@ int main(int argc, char** argv)
             traits->windowDecoration = true;
             traits->doubleBuffer = true;
             traits->sharedContext = 0;
+            traits->readDISPLAY();
+            traits->setUndefinedScreenDetailsToDefaultScreen();
 
             gc = osg::GraphicsContext::createGraphicsContext(traits.get());
             if (!gc)

examples/osgcamera/osgcamera.cpp

@@ -83,7 +83,11 @@ void singleWindowMultipleCameras(osgViewer::Viewer& viewer)
     }
 
     unsigned int width, height;
-    wsi->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(0), width, height);
+    osg::GraphicsContext::ScreenIdentifier main_screen_id;
+
+    main_screen_id.readDISPLAY();
+    main_screen_id.setUndefinedScreenDetailsToDefaultScreen();
+    wsi->getScreenResolution(main_screen_id, width, height);
 
     osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
     traits->x = 0;
@@ -93,6 +97,8 @@ void singleWindowMultipleCameras(osgViewer::Viewer& viewer)
     traits->windowDecoration = true;
     traits->doubleBuffer = true;
     traits->sharedContext = 0;
+    traits->readDISPLAY();
+    traits->setUndefinedScreenDetailsToDefaultScreen();
 
     osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
     if (gc.valid())
@@ -134,7 +140,11 @@ void multipleWindowMultipleCameras(osgViewer::Viewer& viewer, bool multipleScree
     }
 
     unsigned int width, height;
-    wsi->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(0), width, height);
+    osg::GraphicsContext::ScreenIdentifier main_screen_id;
+
+    main_screen_id.readDISPLAY();
+    main_screen_id.setUndefinedScreenDetailsToDefaultScreen();
+    wsi->getScreenResolution(main_screen_id, width, height);
 
 
     unsigned int numCameras = 6;
@@ -151,6 +161,8 @@ void multipleWindowMultipleCameras(osgViewer::Viewer& viewer, bool multipleScree
         traits->windowDecoration = true;
         traits->doubleBuffer = true;
         traits->sharedContext = 0;
+        traits->readDISPLAY();
+        traits->setUndefinedScreenDetailsToDefaultScreen();
 
         osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
         if (gc.valid())

examples/osgcatch/osgcatch.cpp

@@ -971,9 +971,7 @@ bool GameEventHandler::handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionA
                 {
                     createNewCatchable();
                 }
-
-
-
+                break;
             }
             case(osgGA::GUIEventAdapter::KEYDOWN):
             {
@@ -987,6 +985,7 @@ bool GameEventHandler::handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionA
                     _rightKeyPressed=true;
                     return true;
                 }
+                break;
             }
             case(osgGA::GUIEventAdapter::KEYUP):
             {
@@ -1000,6 +999,7 @@ bool GameEventHandler::handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionA
                     _rightKeyPressed=false;
                     return true;
                 }
+                break;
             }
             case(osgGA::GUIEventAdapter::DRAG):
             case(osgGA::GUIEventAdapter::MOVE):

examples/osgcompositeviewer/osgcompositeviewer.cpp

@@ -289,7 +289,11 @@ int main( int argc, char **argv )
         }
 
         unsigned int width, height;
-        wsi->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(0), width, height);
+        osg::GraphicsContext::ScreenIdentifier main_screen_id;
+
+        main_screen_id.readDISPLAY();
+        main_screen_id.setUndefinedScreenDetailsToDefaultScreen();
+        wsi->getScreenResolution(main_screen_id, width, height);
 
         osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
         traits->x = 100;
@@ -299,6 +303,8 @@ int main( int argc, char **argv )
         traits->windowDecoration = true;
         traits->doubleBuffer = true;
         traits->sharedContext = 0;
+        traits->readDISPLAY();
+        traits->setUndefinedScreenDetailsToDefaultScreen();
 
         osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
         if (gc.valid())

examples/osgcubemap/osgcubemap.cpp

@@ -40,33 +40,101 @@
 #include <string>
 #include <vector>
 
-void create_specular_highlights(osg::Node *node)
+int main(int argc, char *argv[])
 {
-    osg::StateSet *ss = node->getOrCreateStateSet();
+    // use an ArgumentParser object to manage the program arguments.
+    osg::ArgumentParser arguments(&argc,argv);
+
+    // construct the viewer.
+    osgViewer::Viewer viewer;
+
+    osg::ref_ptr<osg::TextureCubeMap> tcm = new osg::TextureCubeMap;
 
-    // create and setup the texture object
-    osg::TextureCubeMap *tcm = new osg::TextureCubeMap;
     tcm->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP);
     tcm->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP);
     tcm->setWrap(osg::Texture::WRAP_R, osg::Texture::CLAMP);
-    tcm->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR_MIPMAP_LINEAR);
-    tcm->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
 
-    // generate the six highlight map images (light direction = [1, 1, -1])
-    osgUtil::HighlightMapGenerator *mapgen = new osgUtil::HighlightMapGenerator(
-        osg::Vec3(1, 1, -1),            // light direction
-        osg::Vec4(1, 0.9f, 0.8f, 1),    // light color
-        8);                             // specular exponent
+    if (arguments.read("--no-mip-map"))
+    {
+        tcm->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR);
+        tcm->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
+    }
+    else
+    {
+        tcm->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR_MIPMAP_LINEAR);
+        tcm->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
+    }
 
-    mapgen->generateMap();
+    if (arguments.read("--hardware-mip-map") || arguments.read("--hmp"))
+    {
+        OSG_NOTICE<<"tcm->setUseHardwareMipMapGeneration(true)"<<std::endl;
+        tcm->setUseHardwareMipMapGeneration(true);
+    }
 
-    // assign the six images to the texture object
-    tcm->setImage(osg::TextureCubeMap::POSITIVE_X, mapgen->getImage(osg::TextureCubeMap::POSITIVE_X));
-    tcm->setImage(osg::TextureCubeMap::NEGATIVE_X, mapgen->getImage(osg::TextureCubeMap::NEGATIVE_X));
-    tcm->setImage(osg::TextureCubeMap::POSITIVE_Y, mapgen->getImage(osg::TextureCubeMap::POSITIVE_Y));
-    tcm->setImage(osg::TextureCubeMap::NEGATIVE_Y, mapgen->getImage(osg::TextureCubeMap::NEGATIVE_Y));
-    tcm->setImage(osg::TextureCubeMap::POSITIVE_Z, mapgen->getImage(osg::TextureCubeMap::POSITIVE_Z));
-    tcm->setImage(osg::TextureCubeMap::NEGATIVE_Z, mapgen->getImage(osg::TextureCubeMap::NEGATIVE_Z));
+    std::string filename;
+    if (arguments.read("--posx", filename)) tcm->setImage(osg::TextureCubeMap::POSITIVE_X, osgDB::readImageFile(filename));
+    if (arguments.read("--negx", filename)) tcm->setImage(osg::TextureCubeMap::NEGATIVE_X, osgDB::readImageFile(filename));
+    if (arguments.read("--posy", filename)) tcm->setImage(osg::TextureCubeMap::POSITIVE_Y, osgDB::readImageFile(filename));
+    if (arguments.read("--negy", filename)) tcm->setImage(osg::TextureCubeMap::NEGATIVE_Y, osgDB::readImageFile(filename));
+    if (arguments.read("--posz", filename)) tcm->setImage(osg::TextureCubeMap::POSITIVE_Z, osgDB::readImageFile(filename));
+    if (arguments.read("--negz", filename)) tcm->setImage(osg::TextureCubeMap::NEGATIVE_Z, osgDB::readImageFile(filename));
+
+
+    int numValidImages = 0;
+    if (tcm->getImage(osg::TextureCubeMap::POSITIVE_X)) ++numValidImages;
+    if (tcm->getImage(osg::TextureCubeMap::NEGATIVE_X)) ++numValidImages;
+    if (tcm->getImage(osg::TextureCubeMap::POSITIVE_Y)) ++numValidImages;
+    if (tcm->getImage(osg::TextureCubeMap::NEGATIVE_Y)) ++numValidImages;
+    if (tcm->getImage(osg::TextureCubeMap::POSITIVE_Z)) ++numValidImages;
+    if (tcm->getImage(osg::TextureCubeMap::NEGATIVE_Z)) ++numValidImages;
+
+    if (numValidImages!=6)
+    {
+        // generate the six highlight map images (light direction = [1, 1, -1])
+        osgUtil::HighlightMapGenerator *mapgen = new osgUtil::HighlightMapGenerator(
+            osg::Vec3(1, 1, -1),            // light direction
+            osg::Vec4(1, 0.9f, 0.8f, 1),    // light color
+            8);                             // specular exponent
+
+        mapgen->generateMap();
+
+        // assign the six images to the texture object
+        if (!tcm->getImage(osg::TextureCubeMap::POSITIVE_X)) tcm->setImage(osg::TextureCubeMap::POSITIVE_X, mapgen->getImage(osg::TextureCubeMap::POSITIVE_X));
+        if (!tcm->getImage(osg::TextureCubeMap::NEGATIVE_X)) tcm->setImage(osg::TextureCubeMap::NEGATIVE_X, mapgen->getImage(osg::TextureCubeMap::NEGATIVE_X));
+        if (!tcm->getImage(osg::TextureCubeMap::POSITIVE_Y)) tcm->setImage(osg::TextureCubeMap::POSITIVE_Y, mapgen->getImage(osg::TextureCubeMap::POSITIVE_Y));
+        if (!tcm->getImage(osg::TextureCubeMap::NEGATIVE_Y)) tcm->setImage(osg::TextureCubeMap::NEGATIVE_Y, mapgen->getImage(osg::TextureCubeMap::NEGATIVE_Y));
+        if (!tcm->getImage(osg::TextureCubeMap::POSITIVE_Z)) tcm->setImage(osg::TextureCubeMap::POSITIVE_Z, mapgen->getImage(osg::TextureCubeMap::POSITIVE_Z));
+        if (!tcm->getImage(osg::TextureCubeMap::NEGATIVE_Z)) tcm->setImage(osg::TextureCubeMap::NEGATIVE_Z, mapgen->getImage(osg::TextureCubeMap::NEGATIVE_Z));
+    }
+
+    float LODBias;
+    if (arguments.read("--lod",LODBias))
+    {
+        tcm->setLODBias(LODBias);
+    }
+
+    osg::ref_ptr<osg::Program> program = new osg::Program;
+    std::string shaderFilename;
+    while (arguments.read("-s", shaderFilename))
+    {
+        osg::ref_ptr<osg::Shader> shader = osgDB::readRefShaderFile(shaderFilename);
+        if (shader) program->addShader(shader);
+    }
+
+
+    // load the nodes from the commandline arguments.
+    osg::ref_ptr<osg::Node> rootnode = osgDB::readRefNodeFiles(arguments);
+
+    // if not loaded assume no arguments passed in, try use default mode instead.
+    if (!rootnode) rootnode = osgDB::readRefNodeFile("cessna.osgt");
+
+    if (!rootnode)
+    {
+        osg::notify(osg::NOTICE)<<"Please specify a model filename on the command line."<<std::endl;
+        return 1;
+    }
+
+    osg::StateSet *ss = rootnode->getOrCreateStateSet();
 
     // enable texturing, replacing any textures in the subgraphs
     ss->setTextureAttributeAndModes(0, tcm, osg::StateAttribute::OVERRIDE | osg::StateAttribute::ON);
@@ -84,31 +152,13 @@ void create_specular_highlights(osg::Node *node)
     te->setSource1_RGB(osg::TexEnvCombine::PRIMARY_COLOR);
     te->setOperand1_RGB(osg::TexEnvCombine::SRC_COLOR);
     ss->setTextureAttributeAndModes(0, te, osg::StateAttribute::OVERRIDE | osg::StateAttribute::ON);
-}
 
-int main(int argc, char *argv[])
-{
-    // use an ArgumentParser object to manage the program arguments.
-    osg::ArgumentParser arguments(&argc,argv);
-
-    // construct the viewer.
-    osgViewer::Viewer viewer;
-
-    // load the nodes from the commandline arguments.
-    osg::ref_ptr<osg::Node> rootnode = osgDB::readRefNodeFiles(arguments);
-
-    // if not loaded assume no arguments passed in, try use default mode instead.
-    if (!rootnode) rootnode = osgDB::readRefNodeFile("cessna.osgt");
-
-    if (!rootnode)
+    if (program->getNumShaders()>0)
     {
-        osg::notify(osg::NOTICE)<<"Please specify a model filename on the command line."<<std::endl;
-        return 1;
+        ss->setAttribute(program.get());
+        ss->addUniform(new osg::Uniform("baseTexture",0));
     }
 
-    // create specular highlights
-    create_specular_highlights(rootnode.get());
-
     // run optimization over the scene graph
     osgUtil::Optimizer optimzer;
     optimzer.optimize(rootnode);

examples/osgdistortion/osgdistortion.cpp

@@ -79,7 +79,11 @@ struct CommandLineOptions
             return;
         }
 
-        wsi->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(0), width, height);
+        osg::GraphicsContext::ScreenIdentifier main_screen_id;
+
+        main_screen_id.readDISPLAY();
+        main_screen_id.setUndefinedScreenDetailsToDefaultScreen();
+        wsi->getScreenResolution(main_screen_id, width, height);
         distance = sqrt(sphere_radius*sphere_radius - collar_radius*collar_radius);
     }
 
@@ -274,6 +278,8 @@ void setDomeFaces(osgViewer::Viewer& viewer, CommandLineOptions& options)
     traits->windowDecoration = true;
     traits->doubleBuffer = true;
     traits->sharedContext = 0;
+    traits->readDISPLAY();
+    traits->setUndefinedScreenDetailsToDefaultScreen();
 
     osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
     if (!gc)
@@ -502,6 +508,8 @@ void setDomeCorrection(osgViewer::Viewer& viewer, CommandLineOptions& options)
     traits->windowDecoration = false;
     traits->doubleBuffer = true;
     traits->sharedContext = 0;
+    traits->readDISPLAY();
+    traits->setUndefinedScreenDetailsToDefaultScreen();
 
     osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
     if (!gc)

examples/osgdrawinstanced/osgdrawinstanced.cpp

@@ -59,6 +59,7 @@ createStateSet()
     // render each instance uniquely. gl_InstanceID will be in the range
     // 0 to numInstances-1 (1023 in our case).
     std::string vertexSource =
+        "#extension GL_EXT_gpu_shader4 : enable\n"
         "uniform sampler2D osgLogo; \n"
         "uniform float osg_SimulationTime; \n"
 

examples/osgfont/osgfont.cpp

@@ -12,11 +12,6 @@
 
 void textInfo(osgText::Text* text)
 {
-    const osgText::Text::TextureGlyphQuadMap& tgqm = text->getTextureGlyphQuadMap();
-
-    const osgText::Text::TextureGlyphQuadMap::const_iterator tgqmi = tgqm.begin();
-
-
     osgText::String& s = text->getText();
 
     for(unsigned int i = 0; i < s.size(); i++)

examples/osgforest/osgforest.cpp

@@ -38,6 +38,7 @@
 #include <osg/FragmentProgram>
 
 #include <osgDB/ReadFile>
+#include <osgDB/WriteFile>
 #include <osgDB/FileUtils>
 
 #include <osgUtil/LineSegmentIntersector>
@@ -64,6 +65,18 @@ public:
 
     ForestTechniqueManager() {}
 
+    enum Features
+    {
+        HUD_TEXT = 1,
+        BILLBOARD_GRAPH = 2,
+        X_GRAPH = 4,
+        TRANSFORM_GRAPH = 8,
+        SHADER_GRAPH = 16,
+        GEOMETRY_SHADER_GRAPH = 32,
+        TEXTURE_BUFFER_GRAPH = 64,
+        ALL_FEATURES = (TEXTURE_BUFFER_GRAPH<<1)-1
+    };
+
     class Tree : public osg::Referenced
     {
     public:
@@ -150,7 +163,7 @@ public:
 
     osg::Node* createHUDWithText(const std::string& text);
 
-    osg::Node* createScene(unsigned int numTreesToCreates, unsigned int maxNumTreesPerCell);
+    osg::Node* createScene(unsigned int numTreesToCreates, unsigned int maxNumTreesPerCell, unsigned int mask=ALL_FEATURES);
 
     void advanceToNextTechnique(int delta=1)
     {
@@ -803,6 +816,18 @@ class ShaderGeometry : public osg::Drawable
 
         typedef std::vector<osg::Vec4> PositionSizeList;
 
+        virtual void resizeGLObjectBuffers(unsigned int maxSize)
+        {
+            osg::Drawable::resizeGLObjectBuffers(maxSize);
+            if (_geometry) _geometry->resizeGLObjectBuffers(maxSize);
+        }
+
+        virtual void releaseGLObjects(osg::State* state) const
+        {
+            osg::Drawable::releaseGLObjects(state);
+            if (_geometry) _geometry->releaseGLObjects(state);
+        }
+
         virtual void drawImplementation(osg::RenderInfo& renderInfo) const
         {
             for(PositionSizeList::const_iterator itr = _trees.begin();
@@ -1160,7 +1185,7 @@ osg::Node* ForestTechniqueManager::createHUDWithText(const std::string& str)
     return projection;
 }
 
-osg::Node* ForestTechniqueManager::createScene(unsigned int numTreesToCreates, unsigned int maxNumTreesPerCell)
+osg::Node* ForestTechniqueManager::createScene(unsigned int numTreesToCreates, unsigned int maxNumTreesPerCell, unsigned int mask)
 {
     osg::Vec3 origin(0.0f,0.0f,0.0f);
     osg::Vec3 size(1000.0f,1000.0f,200.0f);
@@ -1206,33 +1231,37 @@ osg::Node* ForestTechniqueManager::createScene(unsigned int numTreesToCreates, u
 
     _techniqueSwitch = new osg::Switch;
 
+    if ((mask & BILLBOARD_GRAPH)!=0)
     {
         std::cout<<"Creating osg::Billboard based forest...";
         osg::Group* group = new osg::Group;
         group->addChild(createBillboardGraph(cell.get(),dstate));
-        group->addChild(createHUDWithText("Using osg::Billboard's to create a forest\n\nPress left cursor key to select geometry instancing with Texture Buffer Object\nPress right cursor key to select double quad based forest"));
+        if ((mask & HUD_TEXT)!=0) group->addChild(createHUDWithText("Using osg::Billboard's to create a forest\n\nPress left cursor key to select geometry instancing with Texture Buffer Object\nPress right cursor key to select double quad based forest"));
         _techniqueSwitch->addChild(group);
         std::cout<<"done."<<std::endl;
     }
 
+    if ((mask & X_GRAPH)!=0)
     {
         std::cout<<"Creating double quad based forest...";
         osg::Group* group = new osg::Group;
         group->addChild(createXGraph(cell.get(),dstate));
-        group->addChild(createHUDWithText("Using double quads to create a forest\n\nPress left cursor key to select osg::Billboard based forest\nPress right cursor key to select osg::MatrixTransform based forest\n"));
+        if ((mask & HUD_TEXT)!=0) group->addChild(createHUDWithText("Using double quads to create a forest\n\nPress left cursor key to select osg::Billboard based forest\nPress right cursor key to select osg::MatrixTransform based forest\n"));
         _techniqueSwitch->addChild(group);
         std::cout<<"done."<<std::endl;
     }
 
+    if ((mask & TRANSFORM_GRAPH)!=0)
     {
         std::cout<<"Creating osg::MatrixTransform based forest...";
         osg::Group* group = new osg::Group;
         group->addChild(createTransformGraph(cell.get(),dstate));
-        group->addChild(createHUDWithText("Using osg::MatrixTransform's to create a forest\n\nPress left cursor key to select double quad based forest\nPress right cursor key to select osg::Vertex/FragmentProgram based forest"));
+        if ((mask & HUD_TEXT)!=0) group->addChild(createHUDWithText("Using osg::MatrixTransform's to create a forest\n\nPress left cursor key to select double quad based forest\nPress right cursor key to select osg::Vertex/FragmentProgram based forest"));
         _techniqueSwitch->addChild(group);
         std::cout<<"done."<<std::endl;
     }
 
+    if ((mask & SHADER_GRAPH)!=0)
     {
         std::cout<<"Creating osg::Vertex/FragmentProgram based forest...";
         osg::Group* group = new osg::Group;
@@ -1289,11 +1318,12 @@ osg::Node* ForestTechniqueManager::createScene(unsigned int numTreesToCreates, u
         }
 
         group->addChild(createShaderGraph(cell.get(),stateset));
-        group->addChild(createHUDWithText("Using osg::Vertex/FragmentProgram to create a forest\n\nPress left cursor key to select osg::MatrixTransform's based forest\nPress right cursor key to select OpenGL shader based forest"));
+        if ((mask & HUD_TEXT)!=0) group->addChild(createHUDWithText("Using osg::Vertex/FragmentProgram to create a forest\n\nPress left cursor key to select osg::MatrixTransform's based forest\nPress right cursor key to select OpenGL shader based forest"));
         _techniqueSwitch->addChild(group);
         std::cout<<"done."<<std::endl;
     }
 
+    if ((mask & SHADER_GRAPH)!=0)
     {
         std::cout<<"Creating OpenGL shader based forest...";
         osg::Group* group = new osg::Group;
@@ -1351,11 +1381,12 @@ osg::Node* ForestTechniqueManager::createScene(unsigned int numTreesToCreates, u
         }
 
         group->addChild(createShaderGraph(cell.get(),stateset));
-        group->addChild(createHUDWithText("Using OpenGL Shader to create a forest\n\nPress left cursor key to select osg::Vertex/FragmentProgram based forest\nPress right cursor key to select osg::Vertex/Geometry/FragmentProgram based forest"));
+        if ((mask & HUD_TEXT)!=0) group->addChild(createHUDWithText("Using OpenGL Shader to create a forest\n\nPress left cursor key to select osg::Vertex/FragmentProgram based forest\nPress right cursor key to select osg::Vertex/Geometry/FragmentProgram based forest"));
         _techniqueSwitch->addChild(group);
         std::cout<<"done."<<std::endl;
     }
 
+    if ((mask & GEOMETRY_SHADER_GRAPH)!=0)
     {
         std::cout<<"Creating Geometry Shader based forest...";
 
@@ -1363,12 +1394,13 @@ osg::Node* ForestTechniqueManager::createScene(unsigned int numTreesToCreates, u
 
         osg::Group* group = new osg::Group;
         group->addChild(createGeometryShaderGraph(cell.get(), stateset));
-        group->addChild(createHUDWithText("Using osg::Vertex/Geometry/FragmentProgram to create a forest\n\nPress left cursor key to select OpenGL Shader based forest\nPress right cursor key to select geometry instancing with Texture Buffer Object"));
+        if ((mask & HUD_TEXT)!=0) group->addChild(createHUDWithText("Using osg::Vertex/Geometry/FragmentProgram to create a forest\n\nPress left cursor key to select OpenGL Shader based forest\nPress right cursor key to select geometry instancing with Texture Buffer Object"));
 
         _techniqueSwitch->addChild(group);
         std::cout<<"done."<<std::endl;
     }
 
+    if ((mask & TEXTURE_BUFFER_GRAPH)!=0)
     {
         std::cout<<"Creating forest using geometry instancing and texture buffer objects ...";
 
@@ -1430,7 +1462,7 @@ osg::Node* ForestTechniqueManager::createScene(unsigned int numTreesToCreates, u
         textureBufferGraph->setStateSet( stateset );
         osg::Group* group = new osg::Group;
         group->addChild(textureBufferGraph);
-        group->addChild(createHUDWithText("Using geometry instancing to create a forest\n\nPress left cursor key to select osg::Vertex/Geometry/FragmentProgram based forest\nPress right cursor key to select osg::Billboard based forest"));
+        if ((mask & HUD_TEXT)!=0) group->addChild(createHUDWithText("Using geometry instancing to create a forest\n\nPress left cursor key to select osg::Vertex/Geometry/FragmentProgram based forest\nPress right cursor key to select osg::Billboard based forest"));
 
         _techniqueSwitch->addChild(group);
 
@@ -1466,6 +1498,16 @@ int main( int argc, char **argv )
 
     arguments.read("--trees-per-cell",maxNumTreesPerCell);
 
+
+    unsigned int features = ForestTechniqueManager::ALL_FEATURES;
+    while(arguments.read("--features", features))
+    {
+        std::cout<<"features = "<<features<<std::endl;
+    }
+
+    std::string outputFilename;
+    while(arguments.read("-o", outputFilename)) {}
+
     osg::ref_ptr<ForestTechniqueManager> ttm = new ForestTechniqueManager;
 
     // add the stats handler
@@ -1475,8 +1517,13 @@ int main( int argc, char **argv )
     viewer.addEventHandler(new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()));
 
     // add model to viewer.
-    viewer.setSceneData( ttm->createScene(numTreesToCreate, maxNumTreesPerCell) );
+    viewer.setSceneData( ttm->createScene(numTreesToCreate, maxNumTreesPerCell, features) );
 
+    if (!outputFilename.empty())
+    {
+        osgDB::writeNodeFile(*viewer.getSceneData(), outputFilename);
+        return 0;
+    }
 
     return viewer.run();
 }

examples/osgfpdepth/osgfpdepth.cpp

@@ -722,6 +722,8 @@ GraphicsContext* setupGC(osgViewer::Viewer& viewer, ArgumentParser& arguments)
     traits->windowDecoration = decoration;
     traits->doubleBuffer = true;
     traits->sharedContext = 0;
+    traits->readDISPLAY();
+    traits->setUndefinedScreenDetailsToDefaultScreen();
 
     ref_ptr<GraphicsContext> gc = GraphicsContext::createGraphicsContext(traits.get());
     osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(gc.get());

examples/osghangglide/hat.cpp

@@ -17,7 +17,7 @@
 */
 
 #ifdef _MSC_VER
-#include <Windows.h>
+#include <windows.h>
 #pragma warning( disable : 4244 )
 #endif
 

examples/osghangglide/osghangglide.cpp

@@ -48,7 +48,7 @@ class MoveEarthySkyWithEyePointTransform : public osg::Transform
 {
 public:
     /** Get the transformation matrix which moves from local coords to world coords.*/
-    virtual bool computeLocalToWorldMatrix(osg::Matrix& matrix,osg::NodeVisitor* nv) const 
+    virtual bool computeLocalToWorldMatrix(osg::Matrix& matrix,osg::NodeVisitor* nv) const
     {
         osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(nv);
         if (cv)
@@ -63,7 +63,7 @@ public:
     virtual bool computeWorldToLocalMatrix(osg::Matrix& matrix,osg::NodeVisitor* nv) const
     {
         std::cout<<"computing transform"<<std::endl;
-    
+
         osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(nv);
         if (cv)
         {
@@ -99,7 +99,7 @@ osg::Group* createModel()
 
     // add the sky and base layer.
     transform->addChild(makeSky());  // bin number -2 so drawn first.
-    transform->addChild(makeBase()); // bin number -1 so draw second.      
+    transform->addChild(makeBase()); // bin number -1 so draw second.
 
     // add the transform to the earth sky.
     clearNode->addChild(transform);
@@ -138,14 +138,14 @@ int main( int argc, char **argv )
         arguments.getApplicationUsage()->write(std::cout);
         return 1;
     }
-    
+
     bool customWindows = false;
     while(arguments.read("-2")) customWindows = true;
 
     if (customWindows)
     {
         osg::GraphicsContext::WindowingSystemInterface* wsi = osg::GraphicsContext::getWindowingSystemInterface();
-        if (!wsi) 
+        if (!wsi)
         {
             osg::notify(osg::NOTICE)<<"View::setUpViewAcrossAllScreens() : Error, no WindowSystemInterface available, cannot create windows."<<std::endl;
             return 0;
@@ -159,6 +159,8 @@ int main( int argc, char **argv )
         traits->windowDecoration = true;
         traits->doubleBuffer = true;
         traits->sharedContext = 0;
+        traits->readDISPLAY();
+        traits->setUndefinedScreenDetailsToDefaultScreen();
 
         osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
         if (gc.valid())
@@ -186,17 +188,17 @@ int main( int argc, char **argv )
 
             viewer.addSlave(camera.get(), osg::Matrixd(), osg::Matrixd::scale(aspectRatioScale,1.0,1.0));
         }
-    }    
+    }
     else
     {
         viewer.setUpViewAcrossAllScreens();
-    
+
     }
 
     // set up the camera manipulation with our custom manipultor
     viewer.setCameraManipulator(new GliderManipulator());
 
-    // pass the scene graph to the viewer    
+    // pass the scene graph to the viewer
     viewer.setSceneData( createModel() );
 
     return viewer.run();

examples/osgmemorytest/osgmemorytest.cpp

@@ -57,7 +57,7 @@ class ContextTest : public MemoryTest
             _width(width),
             _height(height),
             _pbuffer(pbuffer) {}
-        
+
         virtual osg::GraphicsContext* allocate()
         {
             osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
@@ -65,9 +65,11 @@ class ContextTest : public MemoryTest
             traits->height = _height;
             traits->windowDecoration = true;
             traits->pbuffer = _pbuffer;
-            
+            traits->readDISPLAY();
+            traits->setUndefinedScreenDetailsToDefaultScreen();
+
             osg::ref_ptr<osg::GraphicsContext> window = osg::GraphicsContext::createGraphicsContext(traits.get());
-            if (window.valid()) 
+            if (window.valid())
             {
                 if (window->realize())
                 {
@@ -82,15 +84,15 @@ class ContextTest : public MemoryTest
             else
             {
                 std::cerr<<"Error: Unable to create graphics context, problem with running osgViewer-"<<osgViewerGetVersion()<<", cannot create windows/pbuffers."<<std::endl;
-                
+
                 if (_pbuffer) throw "Failed to create PixelBuffer";
                 else  throw "Failed to create GraphicsWindow";
             }
         }
-        
+
 
     protected:
-    
+
         int     _width;
         int     _height;
         bool    _pbuffer;
@@ -102,19 +104,19 @@ class ContextTest : public MemoryTest
 class StateAttributeObject : public GLObject
 {
     public:
-    
+
         StateAttributeObject(osg::StateAttribute* sa): _attribute(sa) {}
-        
+
         void apply(osg::RenderInfo& renderInfo)
         {
             _attribute->apply(*renderInfo.getState());
-            
+
             if (renderInfo.getState()->checkGLErrors(_attribute.get()))
             {
                 throw "OpenGL error";
             }
         }
-        
+
         osg::ref_ptr<osg::StateAttribute> _attribute;
 };
 
@@ -129,40 +131,40 @@ class TextureTest : public GLMemoryTest
             _width(width),
             _height(height),
             _depth(depth) {}
-        
+
         virtual GLObject* allocate()
         {
             if (_depth>1)
             {
                 osg::ref_ptr<osg::Image> image = new osg::Image;
                 image->allocateImage(_width, _height, _depth, GL_RGBA, GL_UNSIGNED_BYTE);
-                
+
                 osg::ref_ptr<osg::Texture3D> texture = new osg::Texture3D;
                 texture->setImage(image.get());
                 texture->setResizeNonPowerOfTwoHint(false);
-                
+
                 return new StateAttributeObject(texture.get());
             }
             if (_height>1)
             {
                 osg::ref_ptr<osg::Image> image = new osg::Image;
                 image->allocateImage(_width, _height, 1, GL_RGBA, GL_UNSIGNED_BYTE);
-                
+
                 osg::ref_ptr<osg::Texture2D> texture = new osg::Texture2D;
                 texture->setImage(image.get());
                 texture->setResizeNonPowerOfTwoHint(false);
-                
+
                 return new StateAttributeObject(texture.get());
             }
             if (_width>1)
             {
                 osg::ref_ptr<osg::Image> image = new osg::Image;
                 image->allocateImage(_width, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE);
-                
+
                 osg::ref_ptr<osg::Texture1D> texture = new osg::Texture1D;
                 texture->setImage(image.get());
                 texture->setResizeNonPowerOfTwoHint(false);
-                
+
                 return new StateAttributeObject(texture.get());
             }
             else
@@ -170,10 +172,10 @@ class TextureTest : public GLMemoryTest
                 throw "Invalid texture size of 0,0,0";
             }
         }
-        
+
 
     protected:
-    
+
         int     _width;
         int     _height;
         int     _depth;
@@ -191,7 +193,7 @@ class FboTest : public GLMemoryTest
             _width(width),
             _height(height),
             _depth(depth) {}
-        
+
         virtual GLObject* allocate()
         {
             osg::ref_ptr<osg::FrameBufferObject> fbo = new osg::FrameBufferObject;
@@ -201,10 +203,10 @@ class FboTest : public GLMemoryTest
 
             return new StateAttributeObject(fbo.get());
         }
-        
+
 
     protected:
-    
+
         int     _width;
         int     _height;
         int     _depth;
@@ -218,19 +220,19 @@ class FboTest : public GLMemoryTest
 class DrawableObject : public GLObject
 {
     public:
-    
+
         DrawableObject(osg::Drawable* drawable): _drawable(drawable) {}
-        
+
         void apply(osg::RenderInfo& renderInfo)
         {
             _drawable->draw(renderInfo);
-            
+
             if (renderInfo.getState()->checkGLErrors("Drawable"))
             {
                 throw "OpenGL error";
             }
         }
-        
+
         osg::ref_ptr<osg::Drawable> _drawable;
 };
 
@@ -240,20 +242,20 @@ class DrawableObject : public GLObject
 class GeometryTest : public GLMemoryTest
 {
     public:
-    
+
         enum GLObjectType
         {
             VERTEX_ARRAY,
             DISPLAY_LIST,
             VERTEX_BUFFER_OBJECT
         };
-    
+
 
         GeometryTest(GLObjectType type, int width=64, int height=64):
             _glObjectType(type),
             _width(width),
             _height(height) {}
-        
+
         virtual GLObject* allocate()
         {
             unsigned int numVertices = _width * _height;
@@ -279,11 +281,11 @@ class GeometryTest : public GLMemoryTest
                     quads->push_back(i   + (j+1)*_width);
                 }
             }
-            
+
             osg::Geometry* geometry = new osg::Geometry;
             geometry->setVertexArray(vertices);
             geometry->addPrimitiveSet(quads);
-            
+
             switch(_glObjectType)
             {
                 case(VERTEX_ARRAY):
@@ -302,10 +304,10 @@ class GeometryTest : public GLMemoryTest
 
             return new DrawableObject(geometry);
         }
-        
+
 
     protected:
-    
+
         GLObjectType    _glObjectType;
         int             _width;
         int             _height;
@@ -314,7 +316,7 @@ class GeometryTest : public GLMemoryTest
 int main( int argc, char **argv )
 {
     osg::ArgumentParser arguments(&argc,argv);
-    
+
     arguments.getApplicationUsage()->setApplicationName(arguments.getApplicationName());
     arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()+" tests OpenGL and Windowing memory scalability..");
     arguments.getApplicationUsage()->addCommandLineOption("-h or --help","List command line options.");
@@ -351,7 +353,7 @@ int main( int argc, char **argv )
 
     ContextTests contextTests;
     GLMemoryTests glMemoryTests;
-    
+
     int width, height, depth;
     while(arguments.read("--pbuffer",width,height)) { contextTests.push_back(new ContextTest(width, height, true)); }
     while(arguments.read("--pbuffer")) { contextTests.push_back(new ContextTest(512, 512, true)); }
@@ -396,20 +398,20 @@ int main( int argc, char **argv )
         return 1;
     }
 #endif
-    
+
     typedef std::list< osg::ref_ptr<osg::GraphicsContext> > Contexts;
     typedef std::list< osg::ref_ptr<GLObject> > GLObjects;
     Contexts allocatedContexts;
     GLObjects glObjects;
-    
+
     if (contextTests.empty())
     {
         if (glMemoryTests.empty())
         {
             std::cout<<"No tests specified, please specify test using the command line options below."<<std::endl<<std::endl;
-        
+
             arguments.getApplicationUsage()->write(std::cout,osg::ApplicationUsage::COMMAND_LINE_OPTION);
-            return 1;            
+            return 1;
         }
         else
         {
@@ -421,14 +423,14 @@ int main( int argc, char **argv )
 
     // use printf's below as C++'s ostream classes use more memory and are more likely to fail when everything
     // goes wrong with memory allocations.
-    
+
     int numContextIterations = 0;
     int numGLObjectIterations = 0;
     int numGLObjectsApplied = 0;
     try
     {
         for(; numGLObjectIterations<maxNumGLIterations; ++numGLObjectIterations)
-        {    
+        {
             for(GLMemoryTests::iterator itr = glMemoryTests.begin();
                 itr != glMemoryTests.end();
                 ++itr)
@@ -437,7 +439,7 @@ int main( int argc, char **argv )
                 if (glObject.valid()) glObjects.push_back(glObject.get());
             }
         }
-        
+
         for(;numContextIterations<maxNumContextIterations; ++numContextIterations)
         {
             printf("GraphicsContext %i\n",numContextIterations);
@@ -451,10 +453,10 @@ int main( int argc, char **argv )
                     allocatedContexts.push_back(context);
 
                     context->makeCurrent();
-                    
+
                     osg::RenderInfo renderInfo;
                     renderInfo.setState(context->getState());
-                    
+
                     for(GLObjects::iterator gitr = glObjects.begin();
                         gitr != glObjects.end();
                         ++gitr)
@@ -466,9 +468,9 @@ int main( int argc, char **argv )
                         (*gitr)->apply(renderInfo);
                         ++numGLObjectsApplied;
                     }
-                    
+
                     context->releaseContext();
-                    
+
                     printf("\n\n"); fflush(stdout);
                 }
             }
@@ -489,7 +491,7 @@ int main( int argc, char **argv )
 
     printf("\nSuccessful completion, contexts created = %i, gl objects applied = %i\n",numContextIterations, numGLObjectsApplied);
     printf("Duration = %f seconds.\n\n",osg::Timer::instance()->delta_s(startTick, endTick));
-    
+
 
     return 0;
 }

examples/osgmovie/osgmovie.cpp

@@ -641,7 +641,11 @@ int main(int argc, char** argv)
         if (wsi)
         {
             unsigned int width, height;
-            wsi->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(0), width, height);
+            osg::GraphicsContext::ScreenIdentifier main_screen_id;
+
+            main_screen_id.readDISPLAY();
+            main_screen_id.setUndefinedScreenDetailsToDefaultScreen();
+            wsi->getScreenResolution(main_screen_id, width, height);
 
             screenAspectRatio = float(width) / float(height);
         }

examples/osgmultiviewpaging/osgmultiviewpaging.cpp

@@ -91,7 +91,11 @@ int main( int argc, char **argv )
         }
 
         unsigned int width, height;
-        wsi->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(0), width, height);
+        osg::GraphicsContext::ScreenIdentifier main_screen_id;
+
+        main_screen_id.readDISPLAY();
+        main_screen_id.setUndefinedScreenDetailsToDefaultScreen();
+        wsi->getScreenResolution(main_screen_id, width, height);
 
         osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
         traits->x = 100;
@@ -101,6 +105,8 @@ int main( int argc, char **argv )
         traits->windowDecoration = true;
         traits->doubleBuffer = true;
         traits->sharedContext = 0;
+        traits->readDISPLAY();
+        traits->setUndefinedScreenDetailsToDefaultScreen();
 
         osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
         if (gc.valid())

examples/osgoscdevice/osgoscdevice.cpp

@@ -109,8 +109,9 @@ bool PickHandler::handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapte
                 user_event->setName("osc_test_1");
 
                 _device->sendEvent(*user_event);
+                return true;
             }
-
+            return false;
         }
 
         default:
@@ -443,6 +444,8 @@ int main( int argc, char **argv )
         traits->doubleBuffer = true;
         traits->sharedContext = 0;
         traits->windowName = "Receiver / view two";
+        traits->readDISPLAY();
+        traits->setUndefinedScreenDetailsToDefaultScreen();
 
         osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
 
@@ -509,6 +512,8 @@ int main( int argc, char **argv )
         traits->doubleBuffer = true;
         traits->sharedContext = 0;
         traits->windowName = "Sender / view one";
+        traits->readDISPLAY();
+        traits->setUndefinedScreenDetailsToDefaultScreen();
 
         osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
 

examples/osgphotoalbum/osgphotoalbum.cpp

@@ -644,6 +644,7 @@ bool SlideEventHandler::handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIAction
             }
 
             _album->setVisibility();
+            return true;
 
         }
 

examples/osgscreencapture/osgscreencapture.cpp

@@ -712,6 +712,8 @@ int main(int argc, char** argv)
         traits->pbuffer = true;
         traits->doubleBuffer = true;
         traits->sharedContext = 0;
+        traits->readDISPLAY();
+        traits->setUndefinedScreenDetailsToDefaultScreen();
 
         pbuffer = osg::GraphicsContext::createGraphicsContext(traits.get());
         if (pbuffer.valid())

examples/osgsidebyside/osgsidebyside.cpp

@@ -182,7 +182,11 @@ void singleWindowSideBySideCameras(osgViewer::Viewer& viewer)
     }
 
     unsigned int width, height;
-    wsi->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(0), width, height);
+    osg::GraphicsContext::ScreenIdentifier main_screen_id;
+
+    main_screen_id.readDISPLAY();
+    main_screen_id.setUndefinedScreenDetailsToDefaultScreen();
+    wsi->getScreenResolution(main_screen_id, width, height);
 
 
 
@@ -198,6 +202,8 @@ void singleWindowSideBySideCameras(osgViewer::Viewer& viewer)
     traits->windowDecoration = true;
     traits->doubleBuffer = true;
     traits->sharedContext = 0;
+    traits->readDISPLAY();
+    traits->setUndefinedScreenDetailsToDefaultScreen();
 
     osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
     if (gc.valid())

examples/osgsimplegl3/osgsimplegl3.cpp

@@ -87,6 +87,8 @@ int main( int argc, char** argv )
     traits->windowDecoration = true;
     traits->doubleBuffer = true;
     traits->glContextVersion = version;
+    traits->readDISPLAY();
+    traits->setUndefinedScreenDetailsToDefaultScreen();
     osg::ref_ptr< osg::GraphicsContext > gc = osg::GraphicsContext::createGraphicsContext( traits.get() );
     if( !gc.valid() )
     {

examples/osgslice/osgslice.cpp

@@ -142,6 +142,8 @@ int main( int argc, char **argv )
     traits->doubleBuffer = true;
     traits->sharedContext = 0;
     traits->pbuffer = false;
+    traits->readDISPLAY();
+    traits->setUndefinedScreenDetailsToDefaultScreen();
 
     osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
     if (!gc || !gc->valid())

examples/osgtext3D/osgtext3D.cpp

@@ -43,9 +43,15 @@ public:
     {
     }
 
-    virtual bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter&)
+    virtual bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
     {
-        if (ea.getEventType() == osgGA::GUIEventAdapter::KEYUP)
+        if (ea.getEventType() == osgGA::GUIEventAdapter::PUSH)
+        {
+            osgViewer::View* view = dynamic_cast<osgViewer::View*>(&aa);
+            if (view) pick(view,ea);
+            return false;
+        }
+        else if (ea.getEventType() == osgGA::GUIEventAdapter::KEYUP)
         {
             if (ea.getKey() == osgGA::GUIEventAdapter::KEY_Up)
             {
@@ -83,6 +89,24 @@ public:
         return false;
     }
 
+    void pick(osgViewer::View* view, const osgGA::GUIEventAdapter& ea)
+    {
+        osgUtil::LineSegmentIntersector::Intersections intersections;
+        if (view->computeIntersections(ea, intersections))
+        {
+            OSG_NOTICE<<"found intersections : "<<std::endl;
+            for(osgUtil::LineSegmentIntersector::Intersections::iterator itr = intersections.begin();
+                itr != intersections.end();
+                ++itr)
+            {
+                OSG_NOTICE<<"    intersection "<<itr->localIntersectionPoint<<std::endl;
+            }
+        }
+        else
+        {
+            OSG_NOTICE<<"failed to get intersection "<<std::endl;
+        }
+    }
 private:
     osgText::Text3D*        m_Text3D;
 };

examples/osgtexturecompression/osgtexturecompression.cpp

@@ -146,7 +146,11 @@ int main(int argc, char** argv)
 
 
     unsigned int width, height;
-    wsi->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(0), width, height);
+    osg::GraphicsContext::ScreenIdentifier main_screen_id;
+
+    main_screen_id.readDISPLAY();
+    main_screen_id.setUndefinedScreenDetailsToDefaultScreen();
+    wsi->getScreenResolution(main_screen_id, width, height);
 
     osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
     traits->x = 0;
@@ -155,6 +159,8 @@ int main(int argc, char** argv)
     traits->height = height;
     traits->windowDecoration = false;
     traits->doubleBuffer = true;
+    traits->readDISPLAY();
+    traits->setUndefinedScreenDetailsToDefaultScreen();
 
     osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
     if (!gc)

examples/osgviewerIPhone/CMakeLists.txt

@@ -27,7 +27,7 @@ SET(TARGET_ADDED_LIBRARIES ${TARGET_ADDED_LIBRARIES}
 #backup setting
 SET(TMP_OSG_BUILD_APPLICATION_BUNDLES {$OSG_BUILD_APPLICATION_BUNDLES})
 SET(OSG_BUILD_APPLICATION_BUNDLES TRUE)
-SET(MACOSX_DEPLOYMENT_TARGET, ${IPHONE_VERSION_MIN})
+#SET(MACOSX_DEPLOYMENT_TARGET, ${IPHONE_VERSION_MIN})
 SETUP_EXAMPLE(osgViewerIPhone)
 SET_TARGET_PROPERTIES(example_osgViewerIPhone PROPERTIES XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY "iPhone Developer"
                                                         XCODE_ATTRIBUTE_IPHONEOS_DEPLOYMENT_TARGET ${IPHONE_VERSION_MIN}
@@ -35,4 +35,4 @@ SET_TARGET_PROPERTIES(example_osgViewerIPhone PROPERTIES XCODE_ATTRIBUTE_CODE_SI
 
 #restore setting
 SET(OSG_BUILD_APPLICATION_BUNDLES {$TMP_OSG_BUILD_APPLICATION_BUNDLES})
-SET(CMAKE_EXE_LINKER_FLAGS "-framework QuartzCore -framework Foundation -framework OpenGLES  -framework UIKit -framework ImageIO -framework CoreImage  -framework MobileCoreServices -framework CoreGraphics")
+SET(CMAKE_EXE_LINKER_FLAGS "-framework QuartzCore -framework Foundation -framework UIKit -framework ImageIO -framework CoreImage -framework MobileCoreServices -framework CoreGraphics")

examples/osgviewerWX/osgviewerWX.cpp

@@ -140,7 +140,8 @@ END_EVENT_TABLE()
 
 OSGCanvas::OSGCanvas(wxWindow *parent, wxWindowID id,
     const wxPoint& pos, const wxSize& size, long style, const wxString& name, int *attributes)
-    : wxGLCanvas(parent, id, pos, size, style|wxFULL_REPAINT_ON_RESIZE, name, attributes)
+    : wxGLCanvas(parent, id, attributes, pos, size, style|wxFULL_REPAINT_ON_RESIZE, name)
+    ,_context(this)
 {
     // default cursor to standard
     _oldCursor = *wxSTANDARD_CURSOR;
@@ -150,6 +151,11 @@ OSGCanvas::~OSGCanvas()
 {
 }
 
+void OSGCanvas::SetContextCurrent()
+{
+	_context.SetCurrent(*this);
+}
+
 void OSGCanvas::OnPaint( wxPaintEvent& WXUNUSED(event) )
 {
     /* must always be here */
@@ -158,8 +164,6 @@ void OSGCanvas::OnPaint( wxPaintEvent& WXUNUSED(event) )
 
 void OSGCanvas::OnSize(wxSizeEvent& event)
 {
-    // this is also necessary to update the context on some platforms
-    wxGLCanvas::OnSize(event);
 
     // set GL viewport (not called by wxGLCanvas::OnSize on all platforms...)
     int width, height;
@@ -337,7 +341,7 @@ void GraphicsWindowWX::useCursor(bool cursorOn)
 
 bool GraphicsWindowWX::makeCurrentImplementation()
 {
-    _canvas->SetCurrent();
+    _canvas->SetContextCurrent();
     return true;
 }
 

examples/osgviewerWX/osgviewerWX.h

@@ -38,12 +38,14 @@ public:
 
     void UseCursor(bool value);
 
+	void SetContextCurrent();
 private:
     DECLARE_EVENT_TABLE()
 
     osg::ref_ptr<osgViewer::GraphicsWindow> _graphics_window;
 
     wxCursor _oldCursor;
+    wxGLContext _context;
 };
 
 class GraphicsWindowWX : public osgViewer::GraphicsWindow

examples/osgvnc/osgvnc.cpp

@@ -25,6 +25,7 @@ class EscapeHandler : public osgGA::GUIEventHandler
 
                         return true;
                     }
+                    break;
                 }
 
                 default:
@@ -95,7 +96,7 @@ int main(int argc,char** argv)
 
     // add a custom escape handler, but disable the standard viewer one to enable the vnc images to handle
     // the escape without it getting caught by the viewer.
-    viewer.addEventHandler(new EscapeHandler);    
+    viewer.addEventHandler(new EscapeHandler);
     viewer.setKeyEventSetsDone(0);
 
     return viewer.run();

examples/osgwindows/osgwindows.cpp

@@ -58,6 +58,8 @@ int main( int argc, char **argv )
         traits->windowDecoration = true;
         traits->doubleBuffer = true;
         traits->sharedContext = 0;
+        traits->readDISPLAY();
+        traits->setUndefinedScreenDetailsToDefaultScreen();
 
         osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
 
@@ -82,6 +84,8 @@ int main( int argc, char **argv )
         traits->windowDecoration = true;
         traits->doubleBuffer = true;
         traits->sharedContext = 0;
+        traits->readDISPLAY();
+        traits->setUndefinedScreenDetailsToDefaultScreen();
 
         osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
 

include/osg/Camera

@@ -599,12 +599,12 @@ class OSG_EXPORT Camera : public Transform, public CullSettings
                 Callback(org, copyop) {}
 
             META_Object(osg, DrawCallback);
-            
+
             /** Functor method called by rendering thread to recursively launch operator() on _nestedcallback **/
             inline void run(osg::RenderInfo& renderInfo) const
             {
                 operator () (renderInfo);
-                
+
                 if (_nestedCallback.valid())
                     ((const DrawCallback*)_nestedCallback.get())->run(renderInfo);
             }
@@ -614,6 +614,23 @@ class OSG_EXPORT Camera : public Transform, public CullSettings
 
             /** Functor method, provided for backwards compatibility, called by operator() (osg::RenderInfo& renderInfo) method.**/
             virtual void operator () (const osg::Camera& /*camera*/) const {}
+
+            /** Resize any per context GLObject buffers to specified size. */
+            virtual void resizeGLObjectBuffers(unsigned int maxSize)
+            {
+                if (_nestedCallback.valid())
+                    _nestedCallback->resizeGLObjectBuffers(maxSize);
+            }
+
+            /** If State is non-zero, this function releases any associated OpenGL objects for
+            * the specified graphics context. Otherwise, releases OpenGL objexts
+            * for all graphics contexts. */
+            virtual void releaseGLObjects(osg::State* state = 0) const
+            {
+                if (_nestedCallback.valid())
+                    _nestedCallback->releaseGLObjects(state);
+            }
+
         };
 
         /** Set the initial draw callback for custom operations to be done before the drawing of the camera's subgraph and pre render stages.*/

include/osg/Drawable

@@ -55,7 +55,7 @@
 #endif
 
 
-// #define INLINE_DRAWABLE_DRAW
+#define INLINE_DRAWABLE_DRAW
 
 namespace osg {
 

include/osg/FrameBufferObject

@@ -304,6 +304,9 @@ class OSG_EXPORT FrameBufferAttachment
         unsigned int getTexture3DZOffset() const;
         unsigned int getTextureArrayLayer() const;
 
+        void resizeGLObjectBuffers(unsigned int maxSize);
+        void releaseGLObjects(osg::State* = 0) const;
+
     private:
         // use the Pimpl idiom to avoid dependency from
         // all Texture* headers

include/osg/GLExtensions

@@ -365,11 +365,21 @@ class OSG_EXPORT GLExtensions : public osg::Referenced
         void (GL_APIENTRY * glUniformMatrix4x3dv)( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value );
         void (GL_APIENTRY * glGetActiveAtomicCounterBufferiv)( GLuint program, GLuint bufferIndex, GLenum pname, GLint* params );
         void (GL_APIENTRY * glDispatchCompute)( GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ );
-        GLuint64 (GL_APIENTRY* glGetTextureHandle)(GLint texture);
-        void        (GL_APIENTRY* glMakeTextureHandleResident)(GLuint64 handle);
-        void        (GL_APIENTRY* glMakeTextureHandleNonResident)(GLuint64 handle);
-        void        (GL_APIENTRY* glUniformHandleui64)(GLint location, GLuint64 handle);
-        GLboolean   (GL_APIENTRY* glIsTextureHandleResident)(GLuint64 handle);
+
+        // ARB_bindless_texture
+        GLuint64 (GL_APIENTRY* glGetTextureHandle)(GLuint texture);
+        GLuint64 (GL_APIENTRY* glGetTextureSamplerHandle)(GLuint texture, GLuint sampler);
+        void (GL_APIENTRY* glMakeTextureHandleResident)(GLuint64 handle);
+        void (GL_APIENTRY* glMakeTextureHandleNonResident)(GLuint64 handle);
+        GLboolean (GL_APIENTRY* glIsTextureHandleResident)(GLuint64 handle);
+        GLuint64 (GL_APIENTRY* glGetImageHandle)(GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format);
+        void (GL_APIENTRY* glMakeImageHandleResident)(GLuint64 handle);
+        void  (GL_APIENTRY* glMakeImageHandleNonResident)(GLuint64 handle);
+        GLboolean (GL_APIENTRY* glIsImageHandleResident)(GLuint64 handle);
+        void  (GL_APIENTRY* glUniformHandleui64)(GLint location, GLuint64 handle);
+        void  (GL_APIENTRY* glUniformHandleuiv64)(GLint location, GLsizei count, GLuint64 *handles);
+        void  (GL_APIENTRY* glProgramUniformHandleui64)(GLuint program, GLint location, GLuint64 handle);
+        void  (GL_APIENTRY* glProgramUniformHandleuiv64)(GLuint program, GLint location, GLsizei count, GLuint64 *handles);
 
         // Buffer Object extensions
         bool isBufferObjectSupported;
@@ -538,7 +548,17 @@ class OSG_EXPORT GLExtensions : public osg::Referenced
                     isNonPowerOfTwoTextureMipMappedSupported;
         }
 
-        void (GL_APIENTRY * glTexStorage2D) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+        ///immutable texture storage and texture view
+        void (GL_APIENTRY * glTexStorage1D) (GLenum target, GLsizei numMipmapLevels, GLenum internalformat, GLsizei width);
+        void (GL_APIENTRY * glTextureStorage1D) (GLuint texture, GLsizei numMipmapLevels, GLenum internalformat, GLsizei width);
+        void (GL_APIENTRY * glTexStorage2D) (GLenum target, GLsizei numMipmapLevels, GLenum internalformat, GLsizei width, GLsizei height);
+        void (GL_APIENTRY * glTextureStorage2D) (GLuint texture, GLsizei numMipmapLevels, GLenum internalformat, GLsizei width, GLsizei height);
+        void (GL_APIENTRY * glTexStorage3D) ( GLenum target, GLsizei numMipmapLevels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+        void (GL_APIENTRY * glTextureStorage3D) ( GLuint texture, GLsizei numMipmapLevels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth);
+        void (GL_APIENTRY * glTexStorage2DMultisample) ( GLenum target, GLsizei numSamples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
+        void (GL_APIENTRY * glTexStorage3DMultisample) ( GLenum target, GLsizei numSamples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
+        void (GL_APIENTRY * glTextureView) ( GLuint texture, GLenum target, GLuint orig, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers);
+
         void (GL_APIENTRY * glCompressedTexImage2D) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
         void (GL_APIENTRY * glCompressedTexSubImage2D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
         void (GL_APIENTRY * glGetCompressedTexImage) (GLenum target, GLint level, GLvoid *data);
@@ -557,8 +577,6 @@ class OSG_EXPORT GLExtensions : public osg::Referenced
 
         void (GL_APIENTRY * glTexImage3D) ( GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
         void (GL_APIENTRY * glTexSubImage3D) ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-        void (GL_APIENTRY * glTexStorage3D) ( GLenum target, GLsizei numMipmapLevels,GLenum sizedInternalFormat,GLsizei width,GLsizei height,GLsizei depth);
-        void (GL_APIENTRY * glTextureStorage3D) ( GLuint texture, GLsizei numMipmapLevels,GLenum sizedInternalFormat,GLsizei width,GLsizei height,GLsizei depth);
 
         void (GL_APIENTRY * glCopyTexSubImage3D) ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height );
         void (GL_APIENTRY * glCompressedTexImage3D) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
@@ -795,6 +813,9 @@ class OSG_EXPORT GLExtensions : public osg::Referenced
 
         /** convenience wrapper around glObjectLabel that calls glObjectLabel if it's supported and using std::string as a label parameter.*/
         void debugObjectLabel(GLenum identifier, GLuint name, const std::string& label) const { if (glObjectLabel && !label.empty()) glObjectLabel(identifier, name, label.size(), label.c_str()); }
+
+    protected:
+        virtual ~GLExtensions();
 };
 
 

include/osg/GraphicsThread

@@ -42,6 +42,14 @@ struct OSG_EXPORT GraphicsOperation : public Operation
     virtual void operator () (Object* object);
 
     virtual void operator () (GraphicsContext* context) = 0;
+
+    /** Resize any per context GLObject buffers to specified size. */
+    virtual void resizeGLObjectBuffers(unsigned int /*maxSize*/) {}
+
+    /** If State is non-zero, this function releases any associated OpenGL objects for
+        * the specified graphics context. Otherwise, releases OpenGL objects
+        * for all graphics contexts. */
+    virtual void releaseGLObjects(osg::State* = 0) const {}
 };
 
 

include/osg/Matrixd

@@ -327,7 +327,7 @@ class OSG_EXPORT Matrixd
         inline Vec4f operator* ( const Vec4f& v ) const;
         inline Vec4d operator* ( const Vec4d& v ) const;
 
-#ifdef USE_DEPRECATED_API
+#ifdef OSG_USE_DEPRECATED_API
         inline void set(const Quat& q) { makeRotate(q); }   /// deprecated, replace with makeRotate(q)
         inline void get(Quat& q) const { q = getRotate(); } /// deprecated, replace with getRotate()
 #endif

include/osg/Matrixf

@@ -328,7 +328,7 @@ class OSG_EXPORT Matrixf
         inline Vec4f operator* ( const Vec4f& v ) const;
         inline Vec4d operator* ( const Vec4d& v ) const;
 
-#ifdef USE_DEPRECATED_API
+#ifdef OSG_USE_DEPRECATED_API
         inline void set(const Quat& q) { makeRotate(q); }
         inline void get(Quat& q) const { q = getRotate(); }
 #endif

include/osg/Object

@@ -25,7 +25,6 @@
 namespace osg {
 
 // forward declare
-class State;
 class UserDataContainer;
 class Node;
 class NodeVisitor;

include/osg/OcclusionQueryNode

@@ -72,6 +72,18 @@ public:
 
     virtual void drawImplementation( osg::RenderInfo& renderInfo ) const;
 
+    struct QueryResult
+    {
+        QueryResult() : valid(false), numPixels(0) {}
+        QueryResult(bool v, unsigned int p) : valid(v), numPixels(p) {}
+
+        bool valid;
+        unsigned int numPixels;
+    };
+
+    /** return a QueryResult for specified Camera, where the QueryResult.valid is true when query results are available, and in which case the QueryResult.numPixels provides the num of pixels in the query result.*/
+    QueryResult getQueryResult( const osg::Camera* cam );
+
     unsigned int getNumPixels( const osg::Camera* cam );
 
     virtual void releaseGLObjects( osg::State* state = 0 ) const;
@@ -125,6 +137,11 @@ public:
     void setQueryFrameCount( unsigned int frames ) { _queryFrameCount = frames; }
     unsigned int getQueryFrameCount() const { return _queryFrameCount; }
 
+    // Resets the queries. The next frame will issue a new query.
+    // This is useful for big view changes, if it shouldn't be waited for
+    // '_queryFrameCount' till the frame contents change.
+    void resetQueries();
+
     // Indicate whether or not the bounding box used in the occlusion query test
     //   should be rendered. Handy for debugging and development.
     // Should only be called outside of cull/draw. No thread issues.
@@ -181,6 +198,9 @@ protected:
 
     bool _enabled;
 
+    // If the box of the query geometry is valid.
+    mutable bool _validQueryGeometry;
+
     // Tracks the last frame number that we performed a query.
     // User can set how many times  (See setQueryFrameCount).
     typedef std::map< const osg::Camera*, unsigned int > FrameCountMap;

include/osg/Quat

@@ -32,7 +32,11 @@ class OSG_EXPORT Quat
     public:
 
         /** Data type of vector components.*/
+        #ifdef OSG_USE_FLOAT_QUAT
+        typedef float value_type;
+        #else
         typedef double value_type;
+        #endif
 
         /** Number of vector components. */
         enum { num_components = 4 };

include/osg/Referenced

@@ -30,6 +30,7 @@ namespace osg {
 class DeleteHandler;
 class Observer;
 class ObserverSet;
+class State;
 
 /** template class to help enforce static initialization order. */
 template <typename T, T M()>
@@ -114,8 +115,16 @@ class OSG_EXPORT Referenced
 
         /** Remove Observer that is observing this object.*/
         void removeObserver(Observer* observer) const;
+#if 0
+         /** Resize any per context GLObject buffers to specified size. */
+        virtual void resizeGLObjectBuffers(unsigned int /*maxSize*/) {}
 
-    public:
+        /** If State is non-zero, this function releases any associated OpenGL objects for
+           * the specified graphics context. Otherwise, releases OpenGL objects
+           * for all graphics contexts. */
+        virtual void releaseGLObjects(osg::State* = 0) const {}
+#endif
+public:
 
         friend class DeleteHandler;
 

include/osg/Shader

@@ -306,6 +306,7 @@ class OSG_EXPORT Shader : public osg::Object
         /** osg::Programs that this osg::Shader is attached to */
         typedef std::set< osg::Program* > ProgramSet;
         ProgramSet                      _programSet;
+        OpenThreads::Mutex _programSetMutex;
         mutable osg::buffered_value< osg::ref_ptr<ShaderObjects> > _pcsList;
 
     private:

include/osg/State

@@ -549,6 +549,13 @@ class OSG_EXPORT State : public Referenced
         /** Set the getCurrentVertexArrayState to the GlobalVertexArrayState.*/
         void setCurrentToGlobalVertexArrayState() { _vas = _globalVertexArrayState.get(); }
 
+        /** Reset the CurrentVertexArrayState/VertexArrayObject if it's value matches the specificied vas - use when deleting a vas.*/
+        void resetCurrentVertexArrayStateOnMatch(VertexArrayState* vas)
+        {
+            if (vas->getVertexArrayObject()== _currentVAO) _currentVAO = 0;
+            if (_vas==vas) _vas = _globalVertexArrayState.get();
+        }
+
 
         /** disable the vertex, normal, color, tex coords, secondary color, fog coord and index arrays.*/
         void disableAllVertexArrays();

include/osg/Texture

@@ -652,8 +652,10 @@ class OSG_EXPORT Texture : public osg::StateAttribute
         /** Get the internal texture format type. */
         inline InternalFormatType getInternalFormatType() const { return _internalFormatType; }
 
-        class TextureObject;
+        /* select the size internal format to use based on Image when available or Texture format settings.*/
+        GLenum selectSizedInternalFormat(const osg::Image* image=0) const;
 
+        class TextureObject;
 
         /** return true if the texture image data has been modified and the associated GL texture object needs to be updated.*/
         virtual bool isDirty(unsigned int /*contextID*/) const { return false; }

include/osg/VertexArrayState

@@ -182,10 +182,12 @@ class OSG_EXPORT VertexArrayState : public osg::Referenced
 
     public:
 
+        virtual ~VertexArrayState();
 
         // osg::GLBufferObject* getGLBufferObject(osg::Array* array);
 
         osg::State*                     _state;
+        osg::ref_ptr<ObserverSet>       _stateObserverSet;
         osg::ref_ptr<osg::GLExtensions> _ext;
 
         bool                            _isVertexBufferObjectSupported;

include/osg/View

@@ -161,6 +161,9 @@ class OSG_EXPORT View : public virtual osg::Object
 
         void updateSlaves();
 
+        virtual void resizeGLObjectBuffers(unsigned int maxSize);
+        virtual void releaseGLObjects(osg::State* = 0) const;
+
     protected :
 
         virtual ~View();

include/osg/observer_ptr

@@ -123,7 +123,7 @@ public:
     bool operator == (const observer_ptr& wp) const { return _reference == wp._reference; }
     bool operator != (const observer_ptr& wp) const { return _reference != wp._reference; }
     bool operator < (const observer_ptr& wp) const { return _reference < wp._reference; }
-    bool operator > (const observer_ptr& wp) const { return _reference > wp._reference; }
+    bool operator > (const observer_ptr& wp) const { return wp._reference < _reference; }
 
     // Non-strict interface, for compatibility
     // comparison operator for const T*.

include/osgDB/ImageOptions

@@ -120,6 +120,8 @@ class OSGDB_EXPORT ImageOptions : public osgDB::Options
             }
 
             double _x,_y,_w,_h;
+        protected:
+            virtual ~TexCoordRange() {}
         };
 
 

include/osgDB/ObjectCache

@@ -55,10 +55,10 @@ class OSGDB_EXPORT ObjectCache : public osg::Referenced
         /** Remove Object from cache.*/
         void removeFromObjectCache(const std::string& fileName, const Options *options = NULL);
 
-        /** Get an Object from the object cache*/
+        /** Deprecated, the getFromObjectCache() returns a C pointer that is not thread safe when using database paging, please use the thread safe getRefFromObjectCache() method instead. */
         osg::Object* getFromObjectCache(const std::string& fileName, const Options *options = NULL);
 
-        /** Get an ref_ptr<Object> from the object cache*/
+        /** Get a thread safe ref_ptr<Object> from the object cache*/
         osg::ref_ptr<osg::Object> getRefFromObjectCache(const std::string& fileName, const Options *options = NULL);
 
         /** call rleaseGLObjects on all objects attached to the object cache.*/

include/osgDB/Serializer

@@ -551,21 +551,24 @@ public:
 };
 
 template<typename C, typename P>
-class ObjectSerializer : public TemplateSerializer<P*>
+class ObjectSerializer : public BaseSerializer
 {
 public:
-    typedef TemplateSerializer<P*> ParentType;
     typedef const P* (C::*Getter)() const;
     typedef void (C::*Setter)( P* );
 
-    ObjectSerializer( const char* name, P* def, Getter gf, Setter sf ) : ParentType(name, def), _getter(gf), _setter(sf)
+    ObjectSerializer( const char* name, P* def, Getter gf, Setter sf ) :
+        BaseSerializer(READ_WRITE_PROPERTY),
+        _name(name), _defaultValue(def), _getter(gf), _setter(sf)
     {
-        ParentType::setUsage( _getter!=0, _setter!=0);
+        setUsage( _getter!=0, _setter!=0);
     }
 
     virtual bool set(osg::Object& obj, void* value) { C& object = OBJECT_CAST<C&>(obj); (object.*_setter)( dynamic_cast<P*>(*(reinterpret_cast<osg::Object**>(value))) ); return true; }
     virtual bool get(const osg::Object& obj, void* value) { const C& object = OBJECT_CAST<const C&>(obj);*(reinterpret_cast<const osg::Object**>(value )) = dynamic_cast<const osg::Object*>((object.*_getter)()); return true; }
 
+    virtual const std::string& getName() const { return _name; }
+
     virtual bool read( InputStream& is, osg::Object& obj )
     {
         C& object = OBJECT_CAST<C&>(obj);
@@ -579,7 +582,7 @@ public:
                 (object.*_setter)( value.get() );
             }
         }
-        else if ( is.matchString(ParentType::_name) )
+        else if ( is.matchString(_name) )
         {
             is >> hasObject;
             if ( hasObject )
@@ -606,9 +609,9 @@ public:
                 os.writeObject( value );
             }
         }
-        else if ( ParentType::_defaultValue!=value )
+        else if ( _defaultValue!=value )
         {
-            os << os.PROPERTY((ParentType::_name).c_str()) << hasObject;
+            os << os.PROPERTY(_name.c_str()) << hasObject;
             if ( hasObject )
             {
                 os << os.BEGIN_BRACKET << std::endl;
@@ -621,8 +624,10 @@ public:
     }
 
 public:
-    Getter _getter;
-    Setter _setter;
+    std::string     _name;
+    osg::ref_ptr<P> _defaultValue;
+    Getter          _getter;
+    Setter          _setter;
 };
 
 template<typename C, typename P>

include/osgDB/StreamOperator

@@ -62,8 +62,9 @@ protected:
     // Return true if the manipulator is std::endl
     bool isEndl( std::ostream& (*fn)(std::ostream&) )
     {
-#ifdef __sun
+#if defined (__sun) || (defined _WIN32 && !defined OSG_LIBRARY_STATIC)
         // What a mess, but solaris does not like taking the address below
+        // windows std::endl is a template with different adresses in different dll's
         std::stringstream ss;
         ss << fn;
         std::string s = ss.str();

include/osgDB/XmlParser

@@ -105,9 +105,9 @@ class OSGDB_EXPORT XmlNode : public osg::Referenced
 
                 size_type currentPosition() const { return _currentPos; }
 
-                int get() { if (_currentPos<_buffer.size()) return _buffer[_currentPos++]; else return -1; }
+                int get() { if (_currentPos<_buffer.size()) return static_cast<unsigned char>(_buffer[_currentPos++]); else return -1; }
 
-                int operator [] (size_type i) const { if ((_currentPos+i)<_buffer.size()) return _buffer[_currentPos+i]; else return -1; }
+                int operator [] (size_type i) const { if ((_currentPos+i)<_buffer.size()) return static_cast<unsigned char>(_buffer[_currentPos+i]); else return -1; }
 
                 void operator ++ () { if (_currentPos<_buffer.size()) ++_currentPos; }
 
@@ -129,12 +129,56 @@ class OSGDB_EXPORT XmlNode : public osg::Referenced
 
                 bool match(const std::string& str) { return (_currentPos<_buffer.size()) ? _buffer.compare(_currentPos, str.size(), str)==0 : false; }
 
+                enum Encoding
+                {
+                    ENCODING_ASCII,
+                    ENCODING_UTF8
+                };
+
+                void setEncoding(Encoding encoding) { _encoding = encoding; }
+                Encoding getEncoding() const { return _encoding; }
+
+                inline void copyCharacterToString(std::string& str)
+                {
+                    if (_currentPos>=_buffer.size()) return;
+                    switch (_encoding)
+                    {
+                        case(ENCODING_UTF8) :
+                        {
+                            int char0 = static_cast<unsigned char>(_buffer[_currentPos]); ++_currentPos;
+                            str.push_back(char0);
+
+                            if (char0 < 0x80 || _currentPos>=_buffer.size()) break; // 1-byte character
+
+                            str.push_back(_buffer[_currentPos]); ++_currentPos;
+                            if (char0<0xe0 || _currentPos<_buffer.size()) break; // 2-byte character
+
+                            str.push_back(_buffer[_currentPos]); ++_currentPos;
+                            if (char0<0xf0 || _currentPos>=_buffer.size()) break; // 3-byte character
+
+                            str.push_back(_buffer[_currentPos]); ++_currentPos;
+                            if (char0<0xf8 || _currentPos>=_buffer.size()) break; // 4-byte character
+
+                            if (_currentPos>=_buffer.size()) break;
+                            str.push_back(_buffer[_currentPos]); ++_currentPos;  // 5-byte character?
+
+                            break;
+                        }
+                        case(ENCODING_ASCII) :
+                        default:
+                            str.push_back(_buffer[_currentPos]);
+                            ++_currentPos;
+                            return;
+                    }
+                }
+
             private:
 
-                size_type _currentPos;
+                size_type       _currentPos;
 
-                std::ifstream _fin;
-                std::string  _buffer;
+                std::ifstream   _fin;
+                std::string     _buffer;
+                Encoding        _encoding;
 
         };
 

include/osgFX/Effect

@@ -119,6 +119,9 @@ namespace osgFX
         /** default traversal */
         inline void inherited_traverse(osg::NodeVisitor& nv);
 
+        virtual void resizeGLObjectBuffers(unsigned int maxSize);
+        virtual void releaseGLObjects(osg::State* state = 0) const;
+
     protected:
         virtual ~Effect();
         Effect &operator=(const Effect &) { return *this; }

include/osgGA/CameraManipulator

@@ -162,7 +162,6 @@ class OSGGA_EXPORT CameraManipulator : public GUIEventHandler
 
         /**
         Start/restart the manipulator.
-        FIXME: what does this actually mean? Provide examples.
         */
         virtual void init(const GUIEventAdapter& ,GUIActionAdapter&) {}
 

include/osgParticle/LinearInterpolator

@@ -42,6 +42,21 @@ namespace osgParticle
             return y1 + (y2 - y1) * t;
         }
 
+        virtual osg::Vec2 interpolate(float t, const osg::Vec2& y1, const osg::Vec2& y2) const
+        {
+            return y1 + (y2 - y1) * t;
+        }
+
+        virtual osg::Vec3 interpolate(float t, const osg::Vec3& y1, const osg::Vec3& y2) const
+        {
+            return y1 + (y2 - y1) * t;
+        }
+
+        virtual osg::Vec4 interpolate(float t, const osg::Vec4& y1, const osg::Vec4& y2) const
+        {
+            return y1 + (y2 - y1) * t;
+        }
+
     protected:
         virtual ~LinearInterpolator() {}
     };

include/osgParticle/ParticleSystem

@@ -265,7 +265,7 @@ namespace osgParticle
           * for all graphics contexts. */
         virtual void releaseGLObjects(osg::State* state=0) const;
 
-        virtual osg::VertexArrayState* createVertexArrayStateImplemenation(osg::RenderInfo& renderInfo) const;
+        virtual osg::VertexArrayState* createVertexArrayStateImplementation(osg::RenderInfo& renderInfo) const;
 
         void adjustEstimatedMaxNumOfParticles(int delta) {  _estimatedMaxNumOfParticles += delta; }
 

include/osgParticle/PrecipitationEffect

@@ -37,8 +37,10 @@ namespace osgParticle
         virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const PrecipitationEffect*>(obj) != 0; }
         virtual void accept(osg::NodeVisitor& nv) { if (nv.validNodeMask(*this)) { nv.pushOntoNodePath(this); nv.apply(*this); nv.popFromNodePath(); } }
 
-        virtual void traverse(osg::NodeVisitor& nv);
+        virtual void resizeGLObjectBuffers(unsigned int maxSize);
+        virtual void releaseGLObjects(osg::State* state = 0) const;
 
+        virtual void traverse(osg::NodeVisitor& nv);
 
         /** Set all the parameters to create an rain effect of specified intensity.*/
         void rain(float intensity);
@@ -117,6 +119,9 @@ namespace osgParticle
             void setNumberOfVertices(unsigned int numVertices) { _numberOfVertices = numVertices; }
             unsigned int getNumberOfVertices() const { return _numberOfVertices; }
 
+            virtual void resizeGLObjectBuffers(unsigned int maxSize);
+            virtual void releaseGLObjects(osg::State* state) const;
+
             virtual void drawImplementation(osg::RenderInfo& renderInfo) const;
 
             struct Cell
@@ -174,7 +179,7 @@ namespace osgParticle
 
         protected:
 
-            virtual ~PrecipitationDrawable() {}
+            virtual ~PrecipitationDrawable();
 
             bool _requiresPreviousMatrix;
 

include/osgSim/SphereSegment

@@ -240,6 +240,10 @@ public:
     /** recompute the primitives rendering meshes/lines thtat represent the sphere segment.*/
     void updatePrimitives();
 
+
+    virtual void resizeGLObjectBuffers(unsigned int maxSize);
+    virtual void releaseGLObjects(osg::State* state = 0) const;
+
     virtual osg::BoundingSphere computeBound() const;
 
 private:

include/osgText/Font

@@ -83,7 +83,7 @@ public:
 
     virtual std::string getFileName() const;
 
-    static osg::ref_ptr<Font>& getDefaultFont();
+    static osg::ref_ptr<Font> getDefaultFont();
 
     typedef std::vector< osg::ref_ptr<osg::StateSet> > StateSets;
     StateSets& getCachedStateSets() { return _statesets; }

include/osgText/Glyph

@@ -28,7 +28,7 @@
 #include <osgText/KerningType>
 #include <osgText/Style>
 
-#include <OpenThreads/Mutex>
+#include <OpenThreads/ReentrantMutex>
 
 namespace osgText {
 
@@ -126,6 +126,8 @@ protected:
 
     typedef std::vector< osg::ref_ptr<TextureInfo> > TextureInfoList;
     TextureInfoList             _textureInfoList;
+
+    mutable OpenThreads::ReentrantMutex  _textureInfoListMutex;
 };
 
 class OSGTEXT_EXPORT GlyphGeometry : public osg::Referenced

include/osgUtil/MeshOptimizers

@@ -46,11 +46,16 @@ class OSGUTIL_EXPORT IndexMeshVisitor : public GeometryCollector
 {
 public:
     IndexMeshVisitor(Optimizer* optimizer = 0)
-        : GeometryCollector(optimizer, Optimizer::INDEX_MESH)
+        : GeometryCollector(optimizer, Optimizer::INDEX_MESH), _generateNewIndicesOnAllGeometries(false)
     {
     }
+    inline void setGenerateNewIndicesOnAllGeometries(bool b) { _generateNewIndicesOnAllGeometries = b; }
+    inline bool getGenerateNewIndicesOnAllGeometries() const { return _generateNewIndicesOnAllGeometries; }
+
     void makeMesh(osg::Geometry& geom);
     void makeMesh();
+protected:
+    bool _generateNewIndicesOnAllGeometries;
 };
 
 // Optimize the triangle order in a mesh for best use of the GPU's

include/osgUtil/RenderLeaf

@@ -72,6 +72,16 @@ class OSGUTIL_EXPORT RenderLeaf : public osg::Referenced
 
         virtual void render(osg::RenderInfo& renderInfo,RenderLeaf* previous);
 
+        virtual void resizeGLObjectBuffers(unsigned int maxSize)
+        {
+            if (_drawable) _drawable->resizeGLObjectBuffers(maxSize);
+        }
+
+        virtual void releaseGLObjects(osg::State* state=0) const
+        {
+            if (_drawable) _drawable->releaseGLObjects(state);
+        }
+
         /// Allow StateGraph to change the RenderLeaf's _parent.
         friend class osgUtil::StateGraph;
 

include/osgUtil/SceneView

@@ -484,6 +484,9 @@ class OSGUTIL_EXPORT SceneView : public osg::Object, public osg::CullSettings
           * then need to be deleted in OpenGL by SceneView::flushAllDeleteGLObjects(). */
         virtual void releaseAllGLObjects();
 
+        virtual void resizeGLObjectBuffers(unsigned int maxSize);
+        virtual void releaseGLObjects(osg::State* = 0) const;
+
         /** Flush all deleted OpenGL objects, such as texture objects, display lists, etc.*/
         virtual void flushAllDeletedGLObjects();
 

include/osgUtil/StateGraph

@@ -38,13 +38,13 @@ struct LessDepthSortFunctor
 
 /** StateGraph - contained in a renderBin, defines the scene to be drawn.
   */
-class OSGUTIL_EXPORT StateGraph : public osg::Referenced
+class OSGUTIL_EXPORT StateGraph : public osg::Object
 {
     public:
 
 
-        typedef std::map< const osg::StateSet*, osg::ref_ptr<StateGraph> >   ChildList;
-        typedef std::vector< osg::ref_ptr<RenderLeaf> >                 LeafList;
+        typedef std::map< const osg::StateSet*, osg::ref_ptr<StateGraph> >  ChildList;
+        typedef std::vector< osg::ref_ptr<RenderLeaf> >                     LeafList;
 
         StateGraph*                         _parent;
 
@@ -66,7 +66,6 @@ class OSGUTIL_EXPORT StateGraph : public osg::Referenced
         bool                                _dynamic;
 
         StateGraph():
-            osg::Referenced(false),
             _parent(NULL),
             _stateset(NULL),
             _depth(0),
@@ -78,7 +77,6 @@ class OSGUTIL_EXPORT StateGraph : public osg::Referenced
         }
 
         StateGraph(StateGraph* parent,const osg::StateSet* stateset):
-            osg::Referenced(false),
             _parent(parent),
             _stateset(stateset),
             _depth(0),
@@ -95,7 +93,13 @@ class OSGUTIL_EXPORT StateGraph : public osg::Referenced
 
         ~StateGraph() {}
 
-        StateGraph* cloneType() const { return new StateGraph; }
+
+        virtual osg::Object* cloneType() const { return new StateGraph(); }
+        virtual StateGraph* cloneStateGraph() const { return new StateGraph(); }
+        virtual osg::Object* clone(const osg::CopyOp&) const { return new StateGraph(); }
+        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const StateGraph*>(obj)!=0L; }
+        virtual const char* libraryName() const { return "osgUtil"; }
+        virtual const char* className() const { return "StateGraph"; }
 
         void setUserData(osg::Referenced* obj) { _userData = obj; }
         osg::Referenced* getUserData() { return _userData.get(); }
@@ -172,6 +176,42 @@ class OSGUTIL_EXPORT StateGraph : public osg::Referenced
         void prune();
 
 
+        void resizeGLObjectBuffers(unsigned int maxSize)
+        {
+            for(ChildList::iterator itr = _children.begin();
+                itr != _children.end();
+                ++itr)
+            {
+                (itr->second)->resizeGLObjectBuffers(maxSize);
+            }
+
+            for(LeafList::iterator itr = _leaves.begin();
+                itr != _leaves.end();
+                ++itr)
+            {
+                (*itr)->resizeGLObjectBuffers(maxSize);
+            }
+        }
+
+        void releaseGLObjects(osg::State* state=0) const
+        {
+            if (_stateset) _stateset->releaseGLObjects(state);
+
+            for(ChildList::const_iterator itr = _children.begin();
+                itr != _children.end();
+                ++itr)
+            {
+                (itr->second)->releaseGLObjects(state);
+            }
+
+            for(LeafList::const_iterator itr = _leaves.begin();
+                itr != _leaves.end();
+                ++itr)
+            {
+                (*itr)->releaseGLObjects(state);
+            }
+        }
+
         inline StateGraph* find_or_insert(const osg::StateSet* stateset)
         {
             // search for the appropriate state group, return it if found.
@@ -309,7 +349,7 @@ class OSGUTIL_EXPORT StateGraph : public osg::Referenced
     private:
 
         /// disallow copy construction.
-        StateGraph(const StateGraph&):osg::Referenced() {}
+        StateGraph(const StateGraph&) : osg::Object() {}
         /// disallow copy operator.
         StateGraph& operator = (const StateGraph&) { return *this; }
 

include/osgViewer/Renderer

@@ -60,6 +60,9 @@ class OSGVIEWER_EXPORT Renderer : public osg::GraphicsOperation
 
         virtual void compile();
 
+        virtual void resizeGLObjectBuffers(unsigned int maxSize);
+        virtual void releaseGLObjects(osg::State* = 0) const;
+
         void setCompileOnNextDraw(bool flag) { _compileOnNextDraw = flag; }
         bool getCompileOnNextDraw() const { return _compileOnNextDraw; }
 

include/osgViewer/Viewer

@@ -113,6 +113,9 @@ class OSGVIEWER_EXPORT Viewer : public ViewerBase, public osgViewer::View
         /** Get the keyboard and mouse usage of this viewer.*/
         virtual void getUsage(osg::ApplicationUsage& usage) const;
 
+        // ensure that osg::View provides the reiszerGLObjects and releaseGLObjects methods
+        virtual void resizeGLObjectBuffers(unsigned int maxSize) { osg::View::resizeGLObjectBuffers(maxSize); }
+        virtual void releaseGLObjects(osg::State* state = 0) const { osg::View::releaseGLObjects(state); }
 
     protected:
 

include/osgWidget/WindowManager

@@ -285,14 +285,16 @@ class OSGWIDGET_EXPORT WindowManager: public osg::Switch, public UIObjectParent<
 
     private:
         // A functor used to sort the Windows by their Z component in descending order.
-        struct WindowZCompare: public std::binary_function<ptr_type, ptr_type, bool> {
+        struct WindowZCompare
+        {
             bool operator()(const ptr_type& x, const ptr_type& y) {
                 return x.get()->getZ() > y.get()->getZ();
             }
         };
 
         // A functor used to sort the Windows by their BinNum component in descending order.
-        struct WindowBinNumberCompare: public std::binary_function<ptr_type, ptr_type, bool> {
+        struct WindowBinNumberCompare
+        {
             bool operator()(const ptr_type& x, const ptr_type& y) {
                 return
                     x.get()->getOrCreateStateSet()->getBinNumber() >

src/OpenThreads/pthreads/CMakeLists.txt

@@ -20,6 +20,11 @@ SET(TARGET_SRC
     ../common/Version.cpp
     ../common/Atomic.cpp
 )
+
+IF(CYGWIN)  # define for pthread_{yield,getconcurrency,setconcurrency}
+    ADD_DEFINITIONS(-D_GNU_SOURCE)
+ENDIF()
+
 IF(ANDROID)
       ADD_DEFINITIONS(-D_GNU_SOURCE)
       SET(CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS} -D_GNU_SOURCE")
@@ -125,7 +130,7 @@ ELSE()
     ENDIF()
 
     IF(APPLE)
-        IF(OSG_BUILD_PLATFORM_IPHONE OR OSG_BUILD_PLATFORM_IPHONE_SIMULATOR)
+        IF(OSG_BUILD_PLATFORM_IPHONE)
             SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES XCODE_ATTRIBUTE_ENABLE_BITCODE ${IPHONE_ENABLE_BITCODE})
         ENDIF()
     ENDIF()

src/osg/Camera.cpp

@@ -330,20 +330,26 @@ void Camera::detach(BufferComponent buffer)
 
 void Camera::resizeGLObjectBuffers(unsigned int maxSize)
 {
-    if (_renderingCache.valid())
-    {
-        const_cast<Camera*>(this)->_renderingCache->resizeGLObjectBuffers(maxSize);
-    }
+    if (_renderer.valid()) _renderer->resizeGLObjectBuffers(maxSize);
+    if (_renderingCache.valid()) _renderingCache->resizeGLObjectBuffers(maxSize);
+
+    if (_initialDrawCallback.valid()) _initialDrawCallback->resizeGLObjectBuffers(maxSize);
+    if (_preDrawCallback.valid()) _preDrawCallback->resizeGLObjectBuffers(maxSize);
+    if (_postDrawCallback.valid()) _postDrawCallback->resizeGLObjectBuffers(maxSize);
+    if (_finalDrawCallback.valid()) _finalDrawCallback->resizeGLObjectBuffers(maxSize);
 
     Transform::resizeGLObjectBuffers(maxSize);
 }
 
 void Camera::releaseGLObjects(osg::State* state) const
 {
-    if (_renderingCache.valid())
-    {
-        const_cast<Camera*>(this)->_renderingCache->releaseGLObjects(state);
-    }
+    if (_renderer.valid()) _renderer->releaseGLObjects(state);
+    if (_renderingCache.valid()) _renderingCache->releaseGLObjects(state);
+
+    if (_initialDrawCallback.valid()) _initialDrawCallback->releaseGLObjects(state);
+    if (_preDrawCallback.valid()) _preDrawCallback->releaseGLObjects(state);
+    if (_postDrawCallback.valid()) _postDrawCallback->releaseGLObjects(state);
+    if (_finalDrawCallback.valid()) _finalDrawCallback->releaseGLObjects(state);
 
     Transform::releaseGLObjects(state);
 }

src/osg/Config.in

@@ -28,6 +28,7 @@
 #cmakedefine OSG_USE_FLOAT_PLANE
 #cmakedefine OSG_USE_FLOAT_BOUNDINGSPHERE
 #cmakedefine OSG_USE_FLOAT_BOUNDINGBOX
+#cmakedefine OSG_USE_FLOAT_QUAT
 #cmakedefine OSG_USE_REF_PTR_IMPLICIT_OUTPUT_CONVERSION
 #cmakedefine OSG_USE_REF_PTR_SAFE_DEREFERENCE
 #cmakedefine OSG_USE_UTF8_FILENAME

src/osg/CullSettings.cpp

@@ -117,6 +117,8 @@ void CullSettings::readEnvironmentalVariables()
 
 void CullSettings::readCommandLine(ArgumentParser& arguments)
 {
+    OSG_INFO<<"CullSettings::readCommandLine(ArgumentParser& arguments)"<<std::endl;
+
     // report the usage options.
     if (arguments.getApplicationUsage())
     {
@@ -124,6 +126,11 @@ void CullSettings::readCommandLine(ArgumentParser& arguments)
         arguments.getApplicationUsage()->addCommandLineOption("--NEAR_FAR_RATIO <float>","Set the ratio between near and far planes - must greater than 0.0 but less than 1.0.");
     }
 
+    while(arguments.read("--NO_CULLING")) setCullingMode(NO_CULLING);
+    while(arguments.read("--VIEW_FRUSTUM")) setCullingMode(VIEW_FRUSTUM_CULLING);
+    while(arguments.read("--VIEW_FRUSTUM_SIDES") || arguments.read("--vfs") ) setCullingMode(VIEW_FRUSTUM_SIDES_CULLING);
+
+
     std::string str;
     while(arguments.read("--COMPUTE_NEAR_FAR_MODE",str))
     {

src/osg/Drawable.cpp

@@ -256,7 +256,28 @@ Drawable::Drawable(const Drawable& drawable,const CopyOp& copyop):
 
 Drawable::~Drawable()
 {
-    dirtyGLObjects();
+    // clean up display lists if assigned, for the display lists size  we can't use glGLObjectSizeHint() as it's a virtual function, so have to default to a 0 size hint.
+    #ifdef OSG_GL_DISPLAYLISTS_AVAILABLE
+    for(unsigned int i=0;i<_globjList.size();++i)
+    {
+        if (_globjList[i] != 0)
+        {
+            Drawable::deleteDisplayList(i,_globjList[i], 0); // we don't know getGLObjectSizeHint()
+            _globjList[i] = 0;
+        }
+    }
+    #endif
+
+    // clean up VertexArrayState
+    for(unsigned int i=0; i<_vertexArrayStateList.size(); ++i)
+    {
+        VertexArrayState* vas = _vertexArrayStateList[i].get();
+        if (vas)
+        {
+            vas->release();
+            _vertexArrayStateList[i] = 0;
+        }
+    }
 }
 
 osg::MatrixList Drawable::getWorldMatrices(const osg::Node* haltTraversalAtNode) const
@@ -318,6 +339,7 @@ void Drawable::releaseGLObjects(State* state) const
         // current OpenGL context.
         unsigned int contextID = state->getContextID();
 
+    #ifdef OSG_GL_DISPLAYLISTS_AVAILABLE
         if (_useDisplayList)
         {
             // get the globj for the current contextID.
@@ -330,6 +352,7 @@ void Drawable::releaseGLObjects(State* state) const
                 globj = 0;
             }
         }
+    #endif
 
         VertexArrayState* vas = contextID <_vertexArrayStateList.size() ? _vertexArrayStateList[contextID].get() : 0;
         if (vas)
@@ -340,7 +363,26 @@ void Drawable::releaseGLObjects(State* state) const
     }
     else
     {
-        const_cast<Drawable*>(this)->dirtyGLObjects();
+    #ifdef OSG_GL_DISPLAYLISTS_AVAILABLE
+        for(unsigned int i=0;i<_globjList.size();++i)
+        {
+            if (_globjList[i] != 0)
+            {
+                Drawable::deleteDisplayList(i,_globjList[i], getGLObjectSizeHint());
+                _globjList[i] = 0;
+            }
+        }
+    #endif
+
+        for(unsigned int i=0; i<_vertexArrayStateList.size(); ++i)
+        {
+            VertexArrayState* vas = _vertexArrayStateList[i].get();
+            if (vas)
+            {
+                vas->release();
+                _vertexArrayStateList[i] = 0;
+            }
+        }
     }
 }
 
@@ -434,9 +476,8 @@ void Drawable::setUseVertexBufferObjects(bool flag)
 
 void Drawable::dirtyGLObjects()
 {
-    unsigned int i;
 #ifdef OSG_GL_DISPLAYLISTS_AVAILABLE
-    for(i=0;i<_globjList.size();++i)
+    for(unsigned int i=0;i<_globjList.size();++i)
     {
         if (_globjList[i] != 0)
         {
@@ -446,7 +487,7 @@ void Drawable::dirtyGLObjects()
     }
 #endif
 
-    for(i=0; i<_vertexArrayStateList.size(); ++i)
+    for(unsigned int i=0; i<_vertexArrayStateList.size(); ++i)
     {
         VertexArrayState* vas = _vertexArrayStateList[i].get();
         if (vas) vas->dirty();

src/osg/FrameBufferObject.cpp

@@ -565,6 +565,18 @@ unsigned int FrameBufferAttachment::getTextureArrayLayer() const
     return _ximpl->zoffset;
 }
 
+void FrameBufferAttachment::resizeGLObjectBuffers(unsigned int maxSize)
+{
+    if (_ximpl->renderbufferTarget.valid()) _ximpl->renderbufferTarget->resizeGLObjectBuffers(maxSize);
+    if (_ximpl->textureTarget.valid()) _ximpl->textureTarget->resizeGLObjectBuffers(maxSize);
+}
+
+void FrameBufferAttachment::releaseGLObjects(osg::State* state) const
+{
+    if (_ximpl->renderbufferTarget.valid()) _ximpl->renderbufferTarget->releaseGLObjects(state);
+    if (_ximpl->textureTarget.valid()) _ximpl->textureTarget->releaseGLObjects(state);
+}
+
 /**************************************************************************
  * FrameBufferObject
  **************************************************************************/
@@ -594,6 +606,11 @@ void FrameBufferObject::resizeGLObjectBuffers(unsigned int maxSize)
     _fboID.resize(maxSize);
     _unsupported.resize(maxSize);
     _fboID.resize(maxSize);
+
+    for(AttachmentMap::iterator itr = _attachments.begin(); itr != _attachments.end(); ++itr)
+    {
+        itr->second.resizeGLObjectBuffers(maxSize);
+    }
 }
 
 void FrameBufferObject::releaseGLObjects(osg::State* state) const
@@ -618,6 +635,11 @@ void FrameBufferObject::releaseGLObjects(osg::State* state) const
             }
         }
     }
+
+    for(AttachmentMap::const_iterator itr = _attachments.begin(); itr != _attachments.end(); ++itr)
+    {
+        itr->second.releaseGLObjects(state);
+    }
 }
 
 void FrameBufferObject::setAttachment(BufferComponent attachment_point, const FrameBufferAttachment &attachment)

src/osg/GLExtensions.cpp

@@ -63,10 +63,6 @@ static osg::buffered_object<ExtensionSet> s_glExtensionSetList;
 static osg::buffered_object<std::string> s_glRendererList;
 static osg::buffered_value<int> s_glInitializedList;
 
-static osg::buffered_object<ExtensionSet> s_gluExtensionSetList;
-static osg::buffered_object<std::string> s_gluRendererList;
-static osg::buffered_value<int> s_gluInitializedList;
-
 static ApplicationUsageProxy GLEXtension_e0(ApplicationUsage::ENVIRONMENTAL_VARIABLE, "OSG_GL_EXTENSION_DISABLE <value>", "Use space deliminarted list of GL extensions to disable associated GL extensions");
 static ApplicationUsageProxy GLEXtension_e1(ApplicationUsage::ENVIRONMENTAL_VARIABLE, "OSG_MAX_TEXTURE_SIZE <value>", "Clamp the maximum GL texture size to specified value.");
 
@@ -399,17 +395,6 @@ OSG_INIT_SINGLETON_PROXY(GLExtensionDisableStringInitializationProxy, osg::getGL
 
     #elif defined (__linux__)
 
-        typedef void (*__GLXextFuncPtr)(void);
-        typedef __GLXextFuncPtr (*GetProcAddressARBProc)(const char*);
-
-        #if !defined(OSG_GLES1_AVAILABLE) && !defined(OSG_GLES2_AVAILABLE)
-        static GetProcAddressARBProc s_glXGetProcAddressARB = convertPointerType<GetProcAddressARBProc, void*>(dlsym(0, "glXGetProcAddressARB"));
-        if (s_glXGetProcAddressARB)
-        {
-            return convertPointerType<void*, __GLXextFuncPtr>((s_glXGetProcAddressARB)(funcName));
-        }
-        #endif
-
         return dlsym(0, funcName);
 
     #elif defined (__QNX__)
@@ -470,7 +455,7 @@ GLExtensions::GLExtensions(unsigned int in_contextID):
     isVertexShaderSupported = validContext && (shadersBuiltIn || osg::isGLExtensionSupported(contextID,"GL_ARB_vertex_shader"));
     isFragmentShaderSupported = validContext && (shadersBuiltIn || osg::isGLExtensionSupported(contextID,"GL_ARB_fragment_shader"));
     isLanguage100Supported = validContext && (shadersBuiltIn || osg::isGLExtensionSupported(contextID,"GL_ARB_shading_language_100"));
-    isGeometryShader4Supported = validContext && (osg::isGLExtensionSupported(contextID,"GL_EXT_geometry_shader4") || osg::isGLExtensionSupported(contextID,"GL_OES_geometry_shader") || osg::isGLExtensionOrVersionSupported(contextID,"GL_ARB_geometry_shader4", 3.2f));
+    isGeometryShader4Supported = validContext && (osg::isGLExtensionSupported(contextID,"GL_EXT_geometry_shader4") || osg::isGLExtensionSupported(contextID,"GL_ARB_geometry_shader4"));
     isGpuShader4Supported = validContext && osg::isGLExtensionOrVersionSupported(contextID,"GL_EXT_gpu_shader4", 3.0f);
     areTessellationShadersSupported = validContext && (osg::isGLExtensionOrVersionSupported(contextID, "GL_ARB_tessellation_shader", 4.0f) || osg::isGLExtensionSupported(contextID,"GL_OES_tessellation_shader"));
     isUniformBufferObjectSupported = validContext && osg::isGLExtensionOrVersionSupported(contextID,"GL_ARB_uniform_buffer_object", 3.1f);
@@ -913,18 +898,6 @@ GLExtensions::GLExtensions(unsigned int in_contextID):
     {
         maxTextureSize = osg_max_size;
     }
-
-    setGLExtensionFuncPtr(glTexStorage2D,"glTexStorage2D","glTexStorage2DARB", validContext);
-    setGLExtensionFuncPtr(glCompressedTexImage2D,"glCompressedTexImage2D","glCompressedTexImage2DARB", validContext);
-    setGLExtensionFuncPtr(glCompressedTexSubImage2D,"glCompressedTexSubImage2D","glCompressedTexSubImage2DARB", validContext);
-    setGLExtensionFuncPtr(glGetCompressedTexImage,"glGetCompressedTexImage","glGetCompressedTexImageARB", validContext);;
-    setGLExtensionFuncPtr(glTexImage2DMultisample, "glTexImage2DMultisample", "glTexImage2DMultisampleARB", validContext);
-
-    setGLExtensionFuncPtr(glTexParameterIiv, "glTexParameterIiv", "glTexParameterIivARB", "glTexParameterIivEXT", validContext);
-    setGLExtensionFuncPtr(glTexParameterIuiv, "glTexParameterIuiv", "glTexParameterIuivARB", "glTexParameterIuivEXT", validContext);
-
-    setGLExtensionFuncPtr(glBindImageTexture, "glBindImageTexture", "glBindImageTextureARB", validContext);
-
     isTextureMaxLevelSupported = (glVersion >= 1.2f);
 
     isTextureStorageEnabled = validContext && ((glVersion >= 4.2f) || isGLExtensionSupported(contextID, "GL_ARB_texture_storage"));
@@ -939,6 +912,27 @@ GLExtensions::GLExtensions(unsigned int in_contextID):
         }
     }
 
+    setGLExtensionFuncPtr(glTexStorage1D,"glTexStorage1D","glTexStorage1DARB", validContext);
+    setGLExtensionFuncPtr(glTextureStorage1D,"glTextureStorage1D","glTextureStorage1DARB", validContext);
+    setGLExtensionFuncPtr(glTexStorage2D,"glTexStorage2D","glTexStorage2DARB", validContext);
+    setGLExtensionFuncPtr(glTextureStorage2D,"glTextureStorage2D","glTextureStorage2DARB", validContext);
+    setGLExtensionFuncPtr(glTexStorage3D, "glTexStorage3D","glTexStorage3DEXT", validContext);
+    setGLExtensionFuncPtr(glTextureStorage3D, "glTextureStorage3D","glTextureStorage3DEXT", validContext);
+    setGLExtensionFuncPtr(glTexStorage2DMultisample, "glTextureStorage2DMultisample","glTextureStorage2DMultisampleEXT", validContext);
+    setGLExtensionFuncPtr(glTexStorage3DMultisample, "glTextureStorage3DMultisample","glTextureStorage3DMultisampleEXT", validContext);
+    setGLExtensionFuncPtr(glTextureView, "glTextureView","glTextureViewEXT", validContext);
+
+    setGLExtensionFuncPtr(glCompressedTexImage2D,"glCompressedTexImage2D","glCompressedTexImage2DARB", validContext);
+    setGLExtensionFuncPtr(glCompressedTexSubImage2D,"glCompressedTexSubImage2D","glCompressedTexSubImage2DARB", validContext);
+    setGLExtensionFuncPtr(glGetCompressedTexImage,"glGetCompressedTexImage","glGetCompressedTexImageARB", validContext);;
+    setGLExtensionFuncPtr(glTexImage2DMultisample, "glTexImage2DMultisample", "glTexImage2DMultisampleARB", validContext);
+
+    setGLExtensionFuncPtr(glTexParameterIiv, "glTexParameterIiv", "glTexParameterIivARB", "glTexParameterIivEXT", validContext);
+    setGLExtensionFuncPtr(glTexParameterIuiv, "glTexParameterIuiv", "glTexParameterIuivARB", "glTexParameterIuivEXT", validContext);
+
+    setGLExtensionFuncPtr(glBindImageTexture, "glBindImageTexture", "glBindImageTextureARB", validContext);
+
+
     // Texture3D extensions
     isTexture3DFast = validContext && (OSG_GL3_FEATURES || isGLExtensionSupported(contextID,"GL_EXT_texture3D"));
 
@@ -950,8 +944,6 @@ GLExtensions::GLExtensions(unsigned int in_contextID):
 
     setGLExtensionFuncPtr(glTexImage3D, "glTexImage3D","glTexImage3DEXT", validContext);
     setGLExtensionFuncPtr(glTexSubImage3D, "glTexSubImage3D","glTexSubImage3DEXT", validContext);
-    setGLExtensionFuncPtr(glTexStorage3D, "glTexStorage3D","glTexStorage3DEXT", validContext);
-    setGLExtensionFuncPtr(glTextureStorage3D, "glTextureStorage3D","glTextureStorage3DEXT", validContext);
 
     setGLExtensionFuncPtr(glCompressedTexImage3D, "glCompressedTexImage3D","glCompressedTexImage3DARB", validContext);
     setGLExtensionFuncPtr(glCompressedTexSubImage3D, "glCompressedTexSubImage3D","glCompressedTexSubImage3DARB", validContext);
@@ -971,12 +963,21 @@ GLExtensions::GLExtensions(unsigned int in_contextID):
     maxLayerCount = 0;
     if (validContext) glGetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, &maxLayerCount);
 
-    // Bindless textures
+    // ARB_bindless_texture
     setGLExtensionFuncPtr(glGetTextureHandle,             "glGetTextureHandle", "glGetTextureHandleARB","glGetTextureHandleNV", validContext);
+    setGLExtensionFuncPtr(glGetTextureSamplerHandle,      "glGetTextureSamplerHandle","glGetTextureSamplerHandleARB", "glGetTextureSamplerHandleNV", validContext);
     setGLExtensionFuncPtr(glMakeTextureHandleResident,    "glMakeTextureHandleResident", "glMakeTextureHandleResidentARB","glMakeTextureHandleResidentNV", validContext);
     setGLExtensionFuncPtr(glMakeTextureHandleNonResident, "glMakeTextureHandleNonResident", "glMakeTextureHandleNonResidentARB", "glMakeTextureHandleNonResidentNV",validContext);
-    setGLExtensionFuncPtr(glUniformHandleui64,            "glUniformHandleui64", "glUniformHandleui64ARB","glUniformHandleui64NV", validContext);
     setGLExtensionFuncPtr(glIsTextureHandleResident,      "glIsTextureHandleResident","glIsTextureHandleResidentARB", "glIsTextureHandleResidentNV", validContext);
+    setGLExtensionFuncPtr(glGetImageHandle,      "glGetImageHandle","glGetImageHandleARB", "glGetImageHandleNV", validContext);
+    setGLExtensionFuncPtr(glMakeImageHandleResident,      "glMakeImageHandleResident","glMakeImageHandleResidentARB", "glMakeImageHandleResidentNV", validContext);
+    setGLExtensionFuncPtr(glMakeImageHandleNonResident,      "glMakeImageHandleNonResident","glMakeImageHandleNonResidentARB", "glMakeImageHandleNonResidentNV", validContext);
+    setGLExtensionFuncPtr(glIsImageHandleResident,      "glIsImageHandleResident","glIsImageHandleResidentARB", "glIsImageHandleResidentNV", validContext);
+    setGLExtensionFuncPtr(glUniformHandleui64,            "glUniformHandleui64", "glUniformHandleui64ARB","glUniformHandleui64NV", validContext);
+    setGLExtensionFuncPtr(glUniformHandleuiv64,      "glUniformHandleuiv64","glUniformHandleuiv64ARB", "glUniformHandleuiv64NV", validContext);
+    setGLExtensionFuncPtr(glProgramUniformHandleui64,      "glProgramUniformHandleui64","glProgramUniformHandleui64ARB", "glProgramUniformHandleui64NV", validContext);
+    setGLExtensionFuncPtr(glProgramUniformHandleuiv64,      "glProgramUniformHandleuiv64","glProgramUniformHandleuiv64ARB", "glProgramUniformHandleuiv64NV", validContext);
+
 
     // Blending
     isBlendColorSupported = validContext &&
@@ -1054,9 +1055,7 @@ GLExtensions::GLExtensions(unsigned int in_contextID):
 
 
     isPointSpriteSupported = validContext && (OSG_GLES2_FEATURES || OSG_GLES3_FEATURES || OSG_GL3_FEATURES || isGLExtensionSupported(contextID, "GL_ARB_point_sprite") || isGLExtensionSupported(contextID, "GL_OES_point_sprite") || isGLExtensionSupported(contextID, "GL_NV_point_sprite"));
-
     isPointSpriteModeSupported = isPointSpriteSupported && !OSG_GL3_FEATURES;
-
     isPointSpriteCoordOriginSupported = validContext && (OSG_GL3_FEATURES || (glVersion >= 2.0f));
 
 
@@ -1281,6 +1280,13 @@ GLExtensions::GLExtensions(unsigned int in_contextID):
 
 }
 
+GLExtensions::~GLExtensions()
+{
+    // Remove s_gl*List
+    s_glExtensionSetList[contextID] = ExtensionSet();
+    s_glRendererList[contextID] = std::string();
+    s_glInitializedList[contextID] = 0;
+}
 
 ///////////////////////////////////////////////////////////////////////////
 // C++-friendly convenience methods

src/osg/GLObjects.cpp

@@ -62,12 +62,10 @@ GraphicsObjectManager::GraphicsObjectManager(const std::string& name, unsigned i
     _name(name),
     _contextID(contextID)
 {
-    OSG_INFO<<_name<<"::"<<_name<<"()"<<this<<std::endl;
 }
 
 GraphicsObjectManager::~GraphicsObjectManager()
 {
-    OSG_INFO<<_name<<"::~"<<_name<<"()"<<this<<std::endl;
 }
 
 

src/osg/Geometry.cpp

@@ -82,10 +82,17 @@ Geometry::Geometry(const Geometry& geometry,const CopyOp& copyop):
 
 Geometry::~Geometry()
 {
-    // do dirty here to keep the getGLObjectSizeHint() estimate on the ball
-    dirtyGLObjects();
-
-    // no need to delete, all automatically handled by ref_ptr :-)
+    // clean up display lists if assigned, and use the GLObjectSizeHint() while prior to it being invalidated by the automatic clean up of arrays that will invalidate the getGLObjectSizeHint() value.
+    #ifdef OSG_GL_DISPLAYLISTS_AVAILABLE
+    for(unsigned int i=0;i<_globjList.size();++i)
+    {
+        if (_globjList[i] != 0)
+        {
+            Drawable::deleteDisplayList(i,_globjList[i], getGLObjectSizeHint());
+            _globjList[i] = 0;
+        }
+    }
+    #endif
 }
 
 #define ARRAY_NOT_EMPTY(array) (array!=0 && array->getNumElements()!=0)

src/osg/GraphicsContext.cpp

@@ -438,7 +438,7 @@ bool GraphicsContext::realize()
 
 void GraphicsContext::close(bool callCloseImplementation)
 {
-    OSG_INFO<<"close("<<callCloseImplementation<<")"<<this<<std::endl;
+    OSG_INFO<<"GraphicsContext::close("<<callCloseImplementation<<")"<<this<<std::endl;
 
     // switch off the graphics thread...
     setGraphicsThread(0);

src/osg/Image.cpp

@@ -356,14 +356,58 @@ GLenum Image::computePixelFormat(GLenum format)
         case(GL_LUMINANCE_ALPHA32F_ARB):
             return GL_LUMINANCE_ALPHA;
 
+        case (GL_R16F):
+        case (GL_R32F):
+        case (GL_R8):
+        case (GL_R8_SNORM):
+        case (GL_R16):
+        case (GL_R16_SNORM):
+            return GL_RED;
+
+        case (GL_R8I):
+        case (GL_R8UI):
+        case (GL_R16I):
+        case (GL_R16UI):
+        case (GL_R32I):
+        case (GL_R32UI):
+            return GL_RED_INTEGER_EXT;
+
+        case (GL_RG16F):
+        case (GL_RG32F):
+        case (GL_RG8):
+        case (GL_RG8_SNORM):
+        case (GL_RG16):
+        case (GL_RG16_SNORM):
+            return GL_RG;
+
+        case (GL_RG8I):
+        case (GL_RG8UI):
+        case (GL_RG16I):
+        case (GL_RG16UI):
+        case (GL_RG32I):
+        case (GL_RG32UI):
+            return GL_RG_INTEGER;
+
         case(GL_RGB32F_ARB):
         case(GL_RGB16F_ARB):
+        case(GL_R3_G3_B2):
+        case(GL_RGB4):
+        case(GL_RGB5):
+        case(GL_RGB8):
+        case(GL_RGB8_SNORM):
+        case(GL_RGB10):
+        case(GL_RGB12):
+        case(GL_SRGB8):
             return GL_RGB;
 
         case(GL_RGBA8):
         case(GL_RGBA16):
         case(GL_RGBA32F_ARB):
         case(GL_RGBA16F_ARB):
+        case(GL_RGBA8_SNORM):
+        case(GL_RGB10_A2):
+        case(GL_RGBA12):
+        case(GL_SRGB8_ALPHA8):
             return GL_RGBA;
 
         case(GL_ALPHA8I_EXT):
@@ -535,9 +579,31 @@ unsigned int Image::computeNumComponents(GLenum pixelFormat)
         case(GL_ALPHA32UI_EXT): return 1;
         case(GL_ALPHA16F_ARB): return 1;
         case(GL_ALPHA32F_ARB): return 1;
+        case(GL_R16F): return 1;
         case(GL_R32F): return 1;
+        case(GL_R8): return 1;
+        case(GL_R8_SNORM): return 1;
+        case(GL_R16): return 1;
+        case(GL_R16_SNORM): return 1;
+        case(GL_R8I): return 1;
+        case(GL_R8UI): return 1;
+        case(GL_R16I): return 1;
+        case(GL_R16UI): return 1;
+        case(GL_R32I): return 1;
+        case(GL_R32UI): return 1;
         case(GL_RG): return 2;
+        case(GL_RG16F): return 2;
         case(GL_RG32F): return 2;
+        case(GL_RG8): return 2;
+        case(GL_RG8_SNORM): return 2;
+        case(GL_RG16): return 2;
+        case(GL_RG16_SNORM): return 2;
+        case(GL_RG8I): return 2;
+        case(GL_RG8UI): return 2;
+        case(GL_RG16I): return 2;
+        case(GL_RG16UI): return 2;
+        case(GL_RG32I): return 2;
+        case(GL_RG32UI): return 2;
         case(GL_RGB): return 3;
         case(GL_BGR): return 3;
         case(GL_RGB8I_EXT): return 3;
@@ -1518,7 +1584,7 @@ void Image::swap(osg::Image& rhs)
 
 void Image::scaleImage(int s,int t,int r, GLenum newDataType)
 {
-    if (_s==s && _t==t && _r==r) return;
+    if (_s==s && _t==t && _r==r && _dataType==newDataType) return;
 
     if (_data==NULL)
     {

src/osg/KdTree.cpp

@@ -492,6 +492,8 @@ KdTree::KdTree(const KdTree& rhs, const osg::CopyOp& copyop):
     Shape(rhs, copyop),
     _degenerateCount(rhs._degenerateCount),
     _vertices(rhs._vertices),
+    _primitiveIndices(rhs._primitiveIndices),
+    _vertexIndices(rhs._vertexIndices),
     _kdNodes(rhs._kdNodes)
 {
 }

src/osg/OcclusionQueryNode.cpp

@@ -364,9 +364,7 @@ QueryGeometry::drawImplementation( osg::RenderInfo& renderInfo ) const
 
 }
 
-
-unsigned int
-QueryGeometry::getNumPixels( const osg::Camera* cam )
+QueryGeometry::QueryResult QueryGeometry::getQueryResult( const osg::Camera* cam )
 {
     osg::ref_ptr<osg::TestResult> tr;
     {
@@ -378,13 +376,20 @@ QueryGeometry::getNumPixels( const osg::Camera* cam )
             _results[ cam ] = tr;
         }
     }
-    return tr->_numPixels;
+    return QueryResult((tr->_init && !tr->_active), tr->_numPixels);
 }
 
+unsigned int
+QueryGeometry::getNumPixels( const osg::Camera* cam )
+{
+    return getQueryResult(cam).numPixels;
+}
 
 void
 QueryGeometry::releaseGLObjects( osg::State* state ) const
 {
+    Geometry::releaseGLObjects(state);
+
     if (!state)
     {
         // delete all query IDs for all contexts.
@@ -437,6 +442,7 @@ QueryGeometry::discardDeletedQueryObjects( unsigned int contextID )
 
 OcclusionQueryNode::OcclusionQueryNode()
   : _enabled( true ),
+    _validQueryGeometry( false ),
     _passed(false),
     _visThreshold( 500 ),
     _queryFrameCount( 5 ),
@@ -454,6 +460,7 @@ OcclusionQueryNode::~OcclusionQueryNode()
 
 OcclusionQueryNode::OcclusionQueryNode( const OcclusionQueryNode& oqn, const CopyOp& copyop )
   : Group( oqn, copyop ),
+    _validQueryGeometry( false ),
     _passed( false )
 {
     _enabled = oqn._enabled;
@@ -469,9 +476,27 @@ OcclusionQueryNode::OcclusionQueryNode( const OcclusionQueryNode& oqn, const Cop
 bool OcclusionQueryNode::getPassed( const Camera* camera, NodeVisitor& nv )
 {
     if ( !_enabled )
+    {
         // Queries are not enabled. The caller should be osgUtil::CullVisitor,
         //   return true to traverse the subgraphs.
-        return true;
+        _passed = true;
+        return _passed;
+    }
+
+    QueryGeometry* qg = static_cast< QueryGeometry* >( _queryGeode->getDrawable( 0 ) );
+
+    if ( !_validQueryGeometry )
+    {
+        // There're cases that the occlusion test result has been retrieved
+        // after the query geometry has been changed, it's the result of the
+        // geometry before the change.
+        qg->reset();
+
+        // The box of the query geometry is invalid, return false to not traverse
+        // the subgraphs.
+        _passed = false;
+        return _passed;
+    }
 
     {
         // Two situations where we want to simply do a regular traversal:
@@ -482,16 +507,19 @@ bool OcclusionQueryNode::getPassed( const Camera* camera, NodeVisitor& nv )
         const unsigned int& lastQueryFrame( _frameCountMap[ camera ] );
         if( ( lastQueryFrame == 0 ) ||
             ( (nv.getTraversalNumber() - lastQueryFrame) >  (_queryFrameCount + 1) ) )
-            return true;
+        {
+            _passed = true;
+            return _passed;
+        }
     }
 
     if (_queryGeode->getDrawable( 0 ) == NULL)
     {
         OSG_FATAL << "osgOQ: OcclusionQueryNode: No QueryGeometry." << std::endl;
         // Something's broke. Return true so we at least render correctly.
-        return true;
+        _passed = true;
+        return _passed;
     }
-    QueryGeometry* qg = static_cast< QueryGeometry* >( _queryGeode->getDrawable( 0 ) );
 
     // Get the near plane for the upcoming distance calculation.
     osg::Matrix::value_type nearPlane;
@@ -511,8 +539,16 @@ bool OcclusionQueryNode::getPassed( const Camera* camera, NodeVisitor& nv )
     _passed = ( distance <= 0.0 );
     if (!_passed)
     {
-        int result = qg->getNumPixels( camera );
-        _passed = ( (unsigned int)(result) > _visThreshold );
+        QueryGeometry::QueryResult result = qg->getQueryResult( camera );
+        if (!result.valid)
+        {
+           // The query hasn't finished yet and the result still
+           // isn't available, return true to traverse the subgraphs.
+           _passed = true;
+           return _passed;
+        }
+
+        _passed = ( result.numPixels > _visThreshold );
     }
 
     return _passed;
@@ -520,6 +556,9 @@ bool OcclusionQueryNode::getPassed( const Camera* camera, NodeVisitor& nv )
 
 void OcclusionQueryNode::traverseQuery( const Camera* camera, NodeVisitor& nv )
 {
+    if (!_validQueryGeometry || ! _enabled)
+        return;
+
     bool issueQuery;
     {
         const int curFrame = nv.getTraversalNumber();
@@ -536,9 +575,11 @@ void OcclusionQueryNode::traverseQuery( const Camera* camera, NodeVisitor& nv )
 
 void OcclusionQueryNode::traverseDebug( NodeVisitor& nv )
 {
-    if (_debugBB)
+    if (_debugBB && _enabled)
+    {
         // If requested, display the debug geometry
         _debugGeode->accept( nv );
+    }
 }
 
 BoundingSphere OcclusionQueryNode::computeBound() const
@@ -557,17 +598,28 @@ BoundingSphere OcclusionQueryNode::computeBound() const
         ComputeBoundsVisitor cbv;
         nonConstThis->accept( cbv );
         BoundingBox bb = cbv.getBoundingBox();
+        const bool bbValid = bb.valid();
+        _validQueryGeometry = bbValid;
 
         osg::ref_ptr<Vec3Array> v = new Vec3Array;
         v->resize( 8 );
-        (*v)[0] = Vec3( bb._min.x(), bb._min.y(), bb._min.z() );
-        (*v)[1] = Vec3( bb._max.x(), bb._min.y(), bb._min.z() );
-        (*v)[2] = Vec3( bb._max.x(), bb._min.y(), bb._max.z() );
-        (*v)[3] = Vec3( bb._min.x(), bb._min.y(), bb._max.z() );
-        (*v)[4] = Vec3( bb._max.x(), bb._max.y(), bb._min.z() );
-        (*v)[5] = Vec3( bb._min.x(), bb._max.y(), bb._min.z() );
-        (*v)[6] = Vec3( bb._min.x(), bb._max.y(), bb._max.z() );
-        (*v)[7] = Vec3( bb._max.x(), bb._max.y(), bb._max.z() );
+
+        // Having (0,0,0) as vertices for the case of the invalid query geometry
+        // still isn't quite the right thing. But the query geometry is public
+        // accessible and therefore a user might expect eight vertices, so
+        // it seems safer to keep eight vertices in the geometry.
+
+        if (bbValid)
+        {
+            (*v)[0] = Vec3( bb._min.x(), bb._min.y(), bb._min.z() );
+            (*v)[1] = Vec3( bb._max.x(), bb._min.y(), bb._min.z() );
+            (*v)[2] = Vec3( bb._max.x(), bb._min.y(), bb._max.z() );
+            (*v)[3] = Vec3( bb._min.x(), bb._min.y(), bb._max.z() );
+            (*v)[4] = Vec3( bb._max.x(), bb._max.y(), bb._min.z() );
+            (*v)[5] = Vec3( bb._min.x(), bb._max.y(), bb._min.z() );
+            (*v)[6] = Vec3( bb._min.x(), bb._max.y(), bb._max.z() );
+            (*v)[7] = Vec3( bb._max.x(), bb._max.y(), bb._max.z() );
+        }
 
         Geometry* geom = static_cast< Geometry* >( nonConstThis->_queryGeode->getDrawable( 0 ) );
         geom->setVertexArray( v.get() );
@@ -586,6 +638,12 @@ void OcclusionQueryNode::setQueriesEnabled( bool enable )
     _enabled = enable;
 }
 
+void OcclusionQueryNode::resetQueries()
+{
+   OpenThreads::ScopedLock<OpenThreads::Mutex> lock( _frameCountMutex );
+   _frameCountMap.clear();
+}
+
 // Should only be called outside of cull/draw. No thread issues.
 void OcclusionQueryNode::setDebugDisplay( bool debug )
 {

src/osg/Shader.cpp

@@ -483,6 +483,7 @@ Shader::PerContextShader* Shader::getPCS(osg::State& state) const
 
 bool Shader::addProgramRef( Program* program )
 {
+    OpenThreads::ScopedLock<OpenThreads::Mutex> lk(_programSetMutex);
     ProgramSet::iterator itr = _programSet.find(program);
     if( itr != _programSet.end() ) return false;
 
@@ -492,6 +493,7 @@ bool Shader::addProgramRef( Program* program )
 
 bool Shader::removeProgramRef( Program* program )
 {
+    OpenThreads::ScopedLock<OpenThreads::Mutex> lk(_programSetMutex);
     ProgramSet::iterator itr = _programSet.find(program);
     if( itr == _programSet.end() ) return false;
 
@@ -507,6 +509,7 @@ void Shader::dirtyShader()
         if( _pcsList[cxt].valid() ) _pcsList[cxt]->requestCompile();
     }
 
+    OpenThreads::ScopedLock<OpenThreads::Mutex> lk(_programSetMutex);
     // Also mark Programs that depend on us as needing relink.
     for( ProgramSet::iterator itr = _programSet.begin();
         itr != _programSet.end(); ++itr )

src/osg/ShapeDrawable.cpp

@@ -13,6 +13,7 @@
 #include <osg/ShapeDrawable>
 #include <osg/GL>
 #include <osg/Notify>
+#include <osg/KdTree>
 
 using namespace osg;
 
@@ -76,6 +77,9 @@ void ShapeDrawable::setTessellationHints(TessellationHints* hints)
 
 void ShapeDrawable::build()
 {
+    // we can't create a tessellation for a KdTree
+    if (dynamic_cast<KdTree*>(_shape.get())!=0) return;
+
     // reset all the properties.
     setVertexArray(0);
     setNormalArray(0);

src/osg/State.cpp

@@ -18,6 +18,7 @@
 #include <osg/Drawable>
 #include <osg/ApplicationUsage>
 #include <osg/ContextData>
+#include <osg/PointSprite>
 #include <osg/os_utils>
 
 #include <sstream>
@@ -285,6 +286,17 @@ void State::initializeExtensionProcs()
         }
     }
 
+    // set the validity of Modes
+    {
+        bool pointSpriteModeValid = _glExtensions->isPointSpriteModeSupported;
+
+    #if defined( OSG_GLES1_AVAILABLE ) //point sprites don't exist on es 2.0
+        setModeValidity(GL_POINT_SPRITE_OES, pointSpriteModeValid);
+    #else
+        setModeValidity(GL_POINT_SPRITE_ARB, pointSpriteModeValid);
+    #endif
+    }
+
 
     _extensionProcsInitialized = true;
 

src/osg/Texture.cpp

@@ -137,6 +137,7 @@ InternalPixelRelations sizedInternalFormats[] = {
 
 
     , { GL_RGBA8                               , GL_RGBA             , GL_UNSIGNED_BYTE                             }
+    , { GL_RGBA16                              , GL_RGBA             , GL_UNSIGNED_SHORT                            }
     , { GL_RGB10_A2                            , GL_RGBA             , GL_UNSIGNED_INT_10_10_10_2                   }
     , { GL_RGB10_A2                            , GL_RGBA             , GL_UNSIGNED_INT_2_10_10_10_REV               }
     , { GL_RGBA12                              , GL_RGBA             , GL_UNSIGNED_SHORT                            }
@@ -149,8 +150,8 @@ InternalPixelRelations sizedInternalFormats[] = {
     , { GL_RGB5_A1                             , GL_RGBA             , GL_UNSIGNED_INT_10_10_10_2                   }
     , { GL_RGB5_A1                             , GL_RGBA             , GL_UNSIGNED_INT_2_10_10_10_REV               }
  // , { GL_RGBA16F                             , GL_RGBA             , GL_HALF_FLOAT                                }
- // , { GL_RGBA16F                             , GL_RGBA             , GL_FLOAT                                     }
- // , { GL_RGBA32F                             , GL_RGBA             , GL_FLOAT                                     }
+    , { GL_RGBA16F_ARB                         , GL_RGBA             , GL_FLOAT                                     }
+    , { GL_RGBA32F_ARB                         , GL_RGBA             , GL_FLOAT                                     }
 
     , { GL_SRGB8                               , GL_RGB              , GL_UNSIGNED_BYTE                             }
     , { GL_SRGB8_ALPHA8                        , GL_RGBA             , GL_UNSIGNED_BYTE                             }
@@ -227,7 +228,7 @@ GLenum assumeSizedInternalFormat(GLint internalFormat, GLenum type)
     return 0;
 }
 
-bool isCompressedInternalFormatSupportedByTexStorrage(GLint internalFormat)
+bool isCompressedInternalFormatSupportedByTexStorage(GLint internalFormat)
 {
     const size_t formatsCount = sizeof(compressedInternalFormats) / sizeof(compressedInternalFormats[0]);
 
@@ -2082,6 +2083,43 @@ bool Texture::areAllTextureObjectsLoaded() const
     return true;
 }
 
+GLenum Texture::selectSizedInternalFormat(const osg::Image* image) const
+{
+    if (image)
+    {
+        bool compressed_image = isCompressedInternalFormat((GLenum)image->getPixelFormat());
+
+        //calculate sized internal format
+        if(compressed_image)
+        {
+            if(isCompressedInternalFormatSupportedByTexStorage(_internalFormat))
+            {
+                return _internalFormat;
+            }
+            else
+            {
+                return 0;
+            }
+        }
+        else
+        {
+            if(isSizedInternalFormat(_internalFormat))
+            {
+                return _internalFormat;
+            }
+            else
+            {
+                return assumeSizedInternalFormat((GLenum)image->getInternalTextureFormat(), (GLenum)image->getDataType());
+            }
+        }
+    }
+    else
+    {
+        if (isSizedInternalFormat(_internalFormat)) return _internalFormat;
+
+        return assumeSizedInternalFormat(_internalFormat, (_sourceType!=0) ? _sourceType : GL_UNSIGNED_BYTE);
+    }
+}
 
 void Texture::applyTexImage2D_load(State& state, GLenum target, const Image* image, GLsizei inwidth, GLsizei inheight,GLsizei numMipmapLevels) const
 {
@@ -2272,49 +2310,21 @@ void Texture::applyTexImage2D_load(State& state, GLenum target, const Image* ima
             int width  = inwidth;
             int height = inheight;
 
-            bool useTexStorrage = extensions->isTextureStorageEnabled;
-            GLenum sizedInternalFormat = 0;
+            GLenum texStoragesizedInternalFormat = extensions->isTextureStorageEnabled && extensions->isTexStorage2DSupported() && (_borderWidth==0) ? selectSizedInternalFormat(image) : 0;
 
-            if(useTexStorrage)
-            {
-                if(extensions->isTexStorage2DSupported() && _borderWidth == 0)
-                {
-                    //calculate sized internal format
-                    if(!compressed_image)
-                    {
-                        if(isSizedInternalFormat(_internalFormat))
-                        {
-                            sizedInternalFormat = _internalFormat;
-                        }
-                        else
-                        {
-                            sizedInternalFormat = assumeSizedInternalFormat((GLenum)image->getInternalTextureFormat(), (GLenum)image->getDataType());
-                        }
-                    }
-                    else
-                    {
-                        if(isCompressedInternalFormatSupportedByTexStorrage(_internalFormat))
-                        {
-                            sizedInternalFormat = _internalFormat;
-                        }
-                    }
-                }
-
-                useTexStorrage &= sizedInternalFormat != 0;
-            }
-
-            if(useTexStorrage)
+            if (texStoragesizedInternalFormat!=0)
             {
                 if (getTextureTarget()==GL_TEXTURE_CUBE_MAP)
                 {
                     if (target==GL_TEXTURE_CUBE_MAP_POSITIVE_X)
                     {
-                        extensions->glTexStorage2D(GL_TEXTURE_CUBE_MAP, numMipmapLevels, sizedInternalFormat, width, height);
+                        // only allocate on first face image
+                        extensions->glTexStorage2D(GL_TEXTURE_CUBE_MAP, numMipmapLevels, texStoragesizedInternalFormat, width, height);
                     }
                 }
                 else
                 {
-                    extensions->glTexStorage2D(target, numMipmapLevels, sizedInternalFormat, width, height);
+                    extensions->glTexStorage2D(target, numMipmapLevels, texStoragesizedInternalFormat, width, height);
                 }
 
                 if( !compressed_image )
@@ -2742,7 +2752,7 @@ Texture::GenerateMipmapMode Texture::mipmapBeforeTexImage(const State& state, bo
             if (useGenerateMipMap) return GENERATE_MIPMAP;
         }
 
-        glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
+        glTexParameteri(getTextureTarget(), GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
         return GENERATE_MIPMAP_TEX_PARAMETER;
 #endif
     }
@@ -2765,7 +2775,7 @@ void Texture::mipmapAfterTexImage(State& state, GenerateMipmapMode beforeResult)
             break;
         }
         case GENERATE_MIPMAP_TEX_PARAMETER:
-            glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_FALSE);
+            glTexParameteri(getTextureTarget(), GL_GENERATE_MIPMAP_SGIS, GL_FALSE);
             break;
         case GENERATE_MIPMAP_NONE:
             break;

src/osg/Texture1D.cpp

@@ -230,18 +230,30 @@ void Texture1D::apply(State& state) const
     }
     else if ( (_textureWidth!=0) && (_internalFormat!=0) )
     {
-        textureObject = generateAndAssignTextureObject(contextID, GL_TEXTURE_1D,_numMipmapLevels,_internalFormat,_textureWidth,1,1,0);
+        // no image present, but dimensions at set so lets create the texture
+        GLExtensions * extensions = state.get<GLExtensions>();
+        GLenum texStorageSizedInternalFormat = extensions->isTextureStorageEnabled ? selectSizedInternalFormat() : 0;
+        if (texStorageSizedInternalFormat!=0)
+        {
+            textureObject = generateAndAssignTextureObject(contextID, GL_TEXTURE_1D, _numMipmapLevels, texStorageSizedInternalFormat, _textureWidth, 1, 1, 0);
+            textureObject->bind();
+            applyTexParameters(GL_TEXTURE_1D, state);
 
-        textureObject->bind();
+            extensions->glTexStorage1D( GL_TEXTURE_1D, osg::maximum(_numMipmapLevels,1), texStorageSizedInternalFormat, _textureWidth);
+        }
+        else
+        {
+            GLenum internalFormat = _sourceFormat ? _sourceFormat : _internalFormat;
+            textureObject = generateAndAssignTextureObject(contextID, GL_TEXTURE_1D, _numMipmapLevels, internalFormat, _textureWidth, 1, 1, 0);
+            textureObject->bind();
+            applyTexParameters(GL_TEXTURE_1D, state);
 
-        applyTexParameters(GL_TEXTURE_1D,state);
-
-        // no image present, but dimensions are set so lets create the texture
-        glTexImage1D( GL_TEXTURE_1D, 0, _internalFormat,
+            glTexImage1D( GL_TEXTURE_1D, 0, _internalFormat,
                      _textureWidth, _borderWidth,
-                     _sourceFormat ? _sourceFormat : _internalFormat,
+                     internalFormat,
                      _sourceType ? _sourceType : GL_UNSIGNED_BYTE,
                      0);
+        }
 
         if (_readPBuffer.valid())
         {