Merge with quitta-gsoc-2013

code/CMakeLists.txt

@@ -106,7 +106,6 @@ IF(WIN32)
   ENDIF(WITH_MFC)
 ENDIF(WIN32)
 
-FIND_PACKAGE(Threads REQUIRED)
 FIND_PACKAGE(LibXml2 REQUIRED)
 FIND_PACKAGE(PNG REQUIRED)
 FIND_PACKAGE(Jpeg)
@@ -114,6 +113,7 @@ FIND_PACKAGE(Jpeg)
 IF(WITH_STATIC_LIBXML2)
   SET(LIBXML2_DEFINITIONS ${LIBXML2_DEFINITIONS} -DLIBXML_STATIC)
 ENDIF(WITH_STATIC_LIBXML2)
+
 IF(WITH_STATIC)
   # libxml2 could need winsock2 library
   SET(LIBXML2_LIBRARIES ${LIBXML2_LIBRARIES} ${WINSOCK2_LIB})
@@ -144,6 +144,31 @@ IF(WITH_NEL)
 
   IF(WITH_GUI)
     FIND_PACKAGE(Libwww REQUIRED)
+    FIND_PACKAGE(Luabind REQUIRED)
+    FIND_PACKAGE(CURL REQUIRED)
+
+    IF(WIN32 OR CURL_LIBRARIES MATCHES "\\.a")
+      SET(CURL_STATIC ON)
+    ENDIF(WIN32 OR CURL_LIBRARIES MATCHES "\\.a")
+
+    IF(CURL_STATIC)
+      SET(CURL_DEFINITIONS -DCURL_STATICLIB)
+
+      FIND_PACKAGE(OpenSSL QUIET)
+
+      IF(OPENSSL_FOUND)
+        SET(CURL_INCLUDE_DIRS ${CURL_INCLUDE_DIRS} ${OPENSSL_INCLUDE_DIR})
+        SET(CURL_LIBRARIES ${CURL_LIBRARIES} ${OPENSSL_LIBRARIES})
+      ENDIF(OPENSSL_FOUND)
+
+      # CURL Macports version depends on libidn, libintl and libiconv too
+      IF(APPLE)
+        FIND_LIBRARY(IDN_LIBRARY idn)
+        FIND_LIBRARY(INTL_LIBRARY intl)
+
+        SET(CURL_LIBRARIES ${CURL_LIBRARIES} ${IDN_LIBRARY} ${INTL_LIBRARY})
+      ENDIF(APPLE)
+    ENDIF(CURL_STATIC)
   ENDIF(WITH_GUI)
 
   INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/nel/include ${LIBXML2_INCLUDE_DIR})

code/CMakeModules/AndroidToolChain.cmake

@@ -0,0 +1,149 @@
+IF(DEFINED CMAKE_CROSSCOMPILING)
+  # subsequent toolchain loading is not really needed
+  RETURN()
+ENDIF()
+
+# Standard settings
+SET(CMAKE_SYSTEM_NAME Linux)
+SET(CMAKE_SYSTEM_VERSION 1) # TODO: determine target Linux version
+SET(UNIX ON)
+SET(LINUX ON)
+SET(ANDROID ON)
+
+IF(NOT NDK_ROOT)
+  SET(NDK_ROOT $ENV{NDK_ROOT})
+
+  IF(CMAKE_HOST_WIN32)
+    FILE(TO_CMAKE_PATH ${NDK_ROOT} NDK_ROOT)
+  ENDIF(CMAKE_HOST_WIN32)
+ENDIF(NOT NDK_ROOT)
+
+IF(NOT TARGET_CPU)
+  SET(TARGET_CPU "armv7")
+ENDIF(NOT TARGET_CPU)
+
+IF(TARGET_CPU STREQUAL "armv7")
+  SET(LIBRARY_ARCHITECTURE "armeabi-v7a")
+  SET(CMAKE_SYSTEM_PROCESSOR "armv7")
+  SET(TOOLCHAIN_ARCH "arm")
+  SET(TOOLCHAIN_PREFIX "arm-linux-androideabi")
+  SET(TOOLCHAIN_BIN_PREFIX "arm")
+  SET(MINIMUM_NDK_TARGET 4)
+ELSEIF(TARGET_CPU STREQUAL "armv5")
+  SET(LIBRARY_ARCHITECTURE "armeabi")
+  SET(CMAKE_SYSTEM_PROCESSOR "armv5")
+  SET(TOOLCHAIN_ARCH "arm")
+  SET(TOOLCHAIN_PREFIX "arm-linux-androideabi")
+  SET(TOOLCHAIN_BIN_PREFIX "arm")
+  SET(MINIMUM_NDK_TARGET 4)
+ELSEIF(TARGET_CPU STREQUAL "x86")
+  SET(LIBRARY_ARCHITECTURE "x86")
+  SET(CMAKE_SYSTEM_PROCESSOR "x86")
+  SET(TOOLCHAIN_ARCH "x86")
+  SET(TOOLCHAIN_PREFIX "x86")
+  SET(TOOLCHAIN_BIN_PREFIX "i686")
+  SET(MINIMUM_NDK_TARGET 9)
+ELSEIF(TARGET_CPU STREQUAL "mips")
+  SET(LIBRARY_ARCHITECTURE "mips")
+  SET(CMAKE_SYSTEM_PROCESSOR "mips")
+  SET(TOOLCHAIN_ARCH "mips")
+  SET(TOOLCHAIN_PREFIX "mipsel-linux-android")
+  SET(TOOLCHAIN_BIN_PREFIX "mipsel")
+  SET(MINIMUM_NDK_TARGET 9)
+ENDIF(TARGET_CPU STREQUAL "armv7")
+
+IF(NOT NDK_TARGET)
+  SET(NDK_TARGET ${MINIMUM_NDK_TARGET})
+ENDIF(NOT NDK_TARGET)
+
+FILE(GLOB _TOOLCHAIN_VERSIONS "${NDK_ROOT}/toolchains/${TOOLCHAIN_PREFIX}-*")
+IF(_TOOLCHAIN_VERSIONS)
+  LIST(SORT _TOOLCHAIN_VERSIONS)
+  LIST(REVERSE _TOOLCHAIN_VERSIONS)
+  FOREACH(_TOOLCHAIN_VERSION ${_TOOLCHAIN_VERSIONS})
+    STRING(REGEX REPLACE ".+${TOOLCHAIN_PREFIX}-([0-9.]+)" "\\1" _TOOLCHAIN_VERSION "${_TOOLCHAIN_VERSION}")
+    IF(_TOOLCHAIN_VERSION MATCHES "^([0-9.]+)$")
+      LIST(APPEND NDK_TOOLCHAIN_VERSIONS ${_TOOLCHAIN_VERSION})
+    ENDIF(_TOOLCHAIN_VERSION MATCHES "^([0-9.]+)$")
+  ENDFOREACH(_TOOLCHAIN_VERSION)
+ENDIF(_TOOLCHAIN_VERSIONS)
+
+IF(NOT NDK_TOOLCHAIN_VERSIONS)
+  MESSAGE(FATAL_ERROR "No Android toolchain found in default search path ${NDK_ROOT}/toolchains")
+ENDIF(NOT NDK_TOOLCHAIN_VERSIONS)
+
+IF(NDK_TOOLCHAIN_VERSION)
+  LIST(FIND NDK_TOOLCHAIN_VERSIONS "${NDK_TOOLCHAIN_VERSION}" _INDEX)
+  IF(_INDEX EQUAL -1)
+    LIST(GET NDK_TOOLCHAIN_VERSIONS 0 NDK_TOOLCHAIN_VERSION)
+  ENDIF(_INDEX EQUAL -1)
+ELSE(NDK_TOOLCHAIN_VERSION)
+  LIST(GET NDK_TOOLCHAIN_VERSIONS 0 NDK_TOOLCHAIN_VERSION)
+ENDIF(NDK_TOOLCHAIN_VERSION)
+
+MESSAGE(STATUS "Target Android NDK ${NDK_TARGET} and use GCC ${NDK_TOOLCHAIN_VERSION}")
+
+IF(CMAKE_HOST_WIN32)
+  SET(TOOLCHAIN_HOST "windows")
+  SET(TOOLCHAIN_BIN_SUFFIX ".exe")
+ELSEIF(CMAKE_HOST_APPLE)
+  SET(TOOLCHAIN_HOST "apple")
+  SET(TOOLCHAIN_BIN_SUFFIX "")
+ELSEIF(CMAKE_HOST_UNIX)
+  SET(TOOLCHAIN_HOST "linux")
+  SET(TOOLCHAIN_BIN_SUFFIX "")
+ENDIF(CMAKE_HOST_WIN32)
+
+SET(TOOLCHAIN_ROOT "${NDK_ROOT}/toolchains/${TOOLCHAIN_PREFIX}-${NDK_TOOLCHAIN_VERSION}/prebuilt/${TOOLCHAIN_HOST}")
+SET(PLATFORM_ROOT "${NDK_ROOT}/platforms/android-${NDK_TARGET}/arch-${TOOLCHAIN_ARCH}")
+
+IF(NOT EXISTS "${TOOLCHAIN_ROOT}")
+  FILE(GLOB _TOOLCHAIN_PREFIXES "${TOOLCHAIN_ROOT}*")
+  IF(_TOOLCHAIN_PREFIXES)
+    LIST(GET _TOOLCHAIN_PREFIXES 0 TOOLCHAIN_ROOT)
+  ENDIF(_TOOLCHAIN_PREFIXES)
+ENDIF(NOT EXISTS "${TOOLCHAIN_ROOT}")
+
+MESSAGE(STATUS "Found Android toolchain in ${TOOLCHAIN_ROOT}")
+MESSAGE(STATUS "Found Android platform in ${PLATFORM_ROOT}")
+
+# include dirs
+SET(PLATFORM_INCLUDE_DIR "${PLATFORM_ROOT}/usr/include")
+SET(STL_DIR "${NDK_ROOT}/sources/cxx-stl/gnu-libstdc++")
+
+IF(EXISTS "${STL_DIR}/${NDK_TOOLCHAIN_VERSION}")
+  # NDK version >= 8b
+  SET(STL_DIR "${STL_DIR}/${NDK_TOOLCHAIN_VERSION}")
+ENDIF(EXISTS "${STL_DIR}/${NDK_TOOLCHAIN_VERSION}")
+
+# Determine bin prefix for toolchain
+FILE(GLOB _TOOLCHAIN_BIN_PREFIXES "${TOOLCHAIN_ROOT}/bin/${TOOLCHAIN_BIN_PREFIX}-*-gcc${TOOLCHAIN_BIN_SUFFIX}")
+IF(_TOOLCHAIN_BIN_PREFIXES)
+  LIST(GET _TOOLCHAIN_BIN_PREFIXES 0 _TOOLCHAIN_BIN_PREFIX)
+  STRING(REGEX REPLACE "${TOOLCHAIN_ROOT}/bin/([a-z0-9-]+)-gcc${TOOLCHAIN_BIN_SUFFIX}" "\\1" TOOLCHAIN_BIN_PREFIX "${_TOOLCHAIN_BIN_PREFIX}")
+ENDIF(_TOOLCHAIN_BIN_PREFIXES)
+
+SET(STL_INCLUDE_DIR "${STL_DIR}/include")
+SET(STL_LIBRARY_DIR "${STL_DIR}/libs/${LIBRARY_ARCHITECTURE}")
+SET(STL_INCLUDE_CPU_DIR "${STL_LIBRARY_DIR}/include")
+SET(STL_LIBRARY "${STL_LIBRARY_DIR}/libgnustl_static.a")
+
+SET(CMAKE_FIND_ROOT_PATH ${TOOLCHAIN_ROOT} ${PLATFORM_ROOT}/usr ${CMAKE_PREFIX_PATH} ${CMAKE_INSTALL_PREFIX} $ENV{EXTERNAL_ANDROID_PATH} CACHE string  "Android find search path root")
+
+SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
+SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+
+INCLUDE_DIRECTORIES(${STL_INCLUDE_DIR} ${STL_INCLUDE_CPU_DIR})
+
+MACRO(SET_TOOLCHAIN_BINARY _NAME _BINARY)
+  SET(${_NAME} ${TOOLCHAIN_ROOT}/bin/${TOOLCHAIN_BIN_PREFIX}-${_BINARY}${TOOLCHAIN_BIN_SUFFIX})
+ENDMACRO(SET_TOOLCHAIN_BINARY)
+
+SET_TOOLCHAIN_BINARY(CMAKE_C_COMPILER gcc)
+SET_TOOLCHAIN_BINARY(CMAKE_CXX_COMPILER g++)
+
+# Force the compilers to GCC for Android
+include (CMakeForceCompiler)
+CMAKE_FORCE_C_COMPILER(${CMAKE_C_COMPILER} GNU)
+CMAKE_FORCE_CXX_COMPILER(${CMAKE_CXX_COMPILER} GNU)

code/CMakeModules/FindCustomMFC.cmake

@@ -4,42 +4,35 @@
 #  MFC_LIBRARY_DIR, where to find libraries
 #  MFC_INCLUDE_DIR, where to find headers
 
-# Try to find MFC using official module, MFC_FOUND is set
-FIND_PACKAGE(MFC)
-
-SET(CUSTOM_MFC_DIR FALSE)
-
-# If using STLport and MFC have been found, remember its directory
-IF(WITH_STLPORT AND MFC_FOUND AND VC_DIR)
-  SET(MFC_STANDARD_DIR "${VC_DIR}/atlmfc")
-ENDIF(WITH_STLPORT AND MFC_FOUND AND VC_DIR)
-
-# If using STLport or MFC haven't been found, search for afxwin.h
-IF(WITH_STLPORT OR NOT MFC_FOUND)
-  FIND_PATH(MFC_DIR
-    include/afxwin.h
-    PATHS
-    ${MFC_STANDARD_DIR}
-  )
-
 IF(CustomMFC_FIND_REQUIRED)
   SET(MFC_FIND_REQUIRED TRUE)
 ENDIF(CustomMFC_FIND_REQUIRED)
 
+# Try to find MFC using official module, MFC_FOUND is set
+FIND_PACKAGE(MFC)
+
+IF(NOT MFC_DIR)
+  # If MFC have been found, remember their directory
+  IF(MFC_FOUND AND VC_DIR)
+    SET(MFC_STANDARD_DIR "${VC_DIR}/atlmfc")
+  ENDIF(MFC_FOUND AND VC_DIR)
+
+  FIND_PATH(MFC_DIR
+    include/afxwin.h
+    HINTS
+    ${MFC_STANDARD_DIR}
+  )
+ENDIF(NOT MFC_DIR)
+
 # Display an error message if MFC are not found, MFC_FOUND is updated
 # User will be able to update MFC_DIR to the correct directory
 INCLUDE(FindPackageHandleStandardArgs)
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(MFC DEFAULT_MSG MFC_DIR)
 
 IF(MFC_FOUND)
-    SET(CUSTOM_MFC_DIR TRUE)
   SET(MFC_INCLUDE_DIR "${MFC_DIR}/include")
   INCLUDE_DIRECTORIES(${MFC_INCLUDE_DIR})
-  ENDIF(MFC_FOUND)
-ENDIF(WITH_STLPORT OR NOT MFC_FOUND)
 
-# Only if using a custom path
-IF(CUSTOM_MFC_DIR)
   # Using 32 or 64 bits libraries
   IF(TARGET_X64)
     SET(MFC_LIBRARY_DIR "${MFC_DIR}/lib/amd64")
@@ -49,9 +42,7 @@ IF(CUSTOM_MFC_DIR)
 
   # Add MFC libraries directory to default library path
   LINK_DIRECTORIES(${MFC_LIBRARY_DIR})
-ENDIF(CUSTOM_MFC_DIR)
 
-IF(MFC_FOUND)
   # Set definitions for using MFC in DLL
   SET(MFC_DEFINITIONS -D_AFXDLL)
 ENDIF(MFC_FOUND)

code/CMakeModules/FindDInput.cmake

@@ -1,38 +0,0 @@
-# - Find DirectInput
-# Find the DirectSound includes and libraries
-#
-#  DINPUT_INCLUDE_DIR - where to find dinput.h
-#  DINPUT_LIBRARIES   - List of libraries when using DirectInput.
-#  DINPUT_FOUND       - True if DirectInput found.
-
-if(DINPUT_INCLUDE_DIR)
-    # Already in cache, be silent
-    set(DINPUT_FIND_QUIETLY TRUE)
-endif(DINPUT_INCLUDE_DIR)
-
-find_path(DINPUT_INCLUDE_DIR dinput.h 
-  "$ENV{DXSDK_DIR}" 
-  "$ENV{DXSDK_DIR}/Include"
-)
-
-find_library(DINPUT_LIBRARY 
-  NAMES dinput dinput8 
-  PATHS
-  "$ENV{DXSDK_DIR}"
-  "$ENV{DXSDK_DIR}/Lib"
-  "$ENV{DXSDK_DIR}/Lib/x86"
-)
-
-# Handle the QUIETLY and REQUIRED arguments and set DINPUT_FOUND to TRUE if
-# all listed variables are TRUE.
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(DINPUT DEFAULT_MSG
-    DINPUT_INCLUDE_DIR DINPUT_LIBRARY)
-
-if(DINPUT_FOUND)
-    set(DINPUT_LIBRARIES ${DINPUT_LIBRARY})
-else(DINPUT_FOUND)
-    set(DINPUT_LIBRARIES)
-endif(DINPUT_FOUND)
-
-mark_as_advanced(DINPUT_INCLUDE_DIR DINPUT_LIBRARY)

code/CMakeModules/FindFreeType.cmake

@@ -1,14 +1,13 @@
 # - Locate FreeType library
 # This module defines
-#  FREETYPE_LIBRARY, the library to link against
+#  FREETYPE_LIBRARIES, libraries to link against
 #  FREETYPE_FOUND, if false, do not try to link to FREETYPE
 #  FREETYPE_INCLUDE_DIRS, where to find headers.
 
-IF(FREETYPE_LIBRARY AND FREETYPE_INCLUDE_DIRS)
+IF(FREETYPE_LIBRARIES AND FREETYPE_INCLUDE_DIRS)
   # in cache already
-  SET(FREETYPE_FIND_QUIETLY TRUE)
+  SET(Freetype_FIND_QUIETLY TRUE)
-ENDIF(FREETYPE_LIBRARY AND FREETYPE_INCLUDE_DIRS)
+ENDIF(FREETYPE_LIBRARIES AND FREETYPE_INCLUDE_DIRS)
-
 
 FIND_PATH(FREETYPE_INCLUDE_DIRS
   freetype
@@ -40,7 +39,7 @@ IF(FREETYPE_ADDITIONAL_INCLUDE_DIR)
   SET(FREETYPE_INCLUDE_DIRS ${FREETYPE_INCLUDE_DIRS} ${FREETYPE_ADDITIONAL_INCLUDE_DIR})
 ENDIF(FREETYPE_ADDITIONAL_INCLUDE_DIR)
 
-FIND_LIBRARY(FREETYPE_LIBRARY
+FIND_LIBRARY(FREETYPE_LIBRARY_RELEASE
   NAMES freetype libfreetype freetype219 freetype246
   PATHS
   $ENV{FREETYPE_DIR}/lib
@@ -53,22 +52,54 @@ FIND_LIBRARY(FREETYPE_LIBRARY
   /opt/csw/lib
   /opt/lib
   /usr/freeware/lib64
+  /usr/lib/x86_64-linux-gnu
 )
 
-IF(FREETYPE_LIBRARY AND FREETYPE_INCLUDE_DIRS)
+FIND_LIBRARY(FREETYPE_LIBRARY_DEBUG
-  SET(FREETYPE_FOUND "YES")
+  NAMES freetyped libfreetyped freetype219d freetype246d
+  PATHS
+  $ENV{FREETYPE_DIR}/lib
+  /usr/local/lib
+  /usr/lib
+  /usr/local/X11R6/lib
+  /usr/X11R6/lib
+  /sw/lib
+  /opt/local/lib
+  /opt/csw/lib
+  /opt/lib
+  /usr/freeware/lib64
+  /usr/lib/x86_64-linux-gnu
+)
+
+IF(FREETYPE_INCLUDE_DIRS)
+  IF(FREETYPE_LIBRARY_RELEASE AND FREETYPE_LIBRARY_DEBUG)
+    # Case where both Release and Debug versions are provided
+    SET(FREETYPE_FOUND ON)
+    SET(FREETYPE_LIBRARIES optimized ${FREETYPE_LIBRARY_RELEASE} debug ${FREETYPE_LIBRARY_DEBUG})
+  ELSEIF(FREETYPE_LIBRARY_RELEASE)
+    # Normal case
+    SET(FREETYPE_FOUND ON)
+    SET(FREETYPE_LIBRARIES ${FREETYPE_LIBRARY_RELEASE})
+  ELSEIF(FREETYPE_LIBRARY_DEBUG)
+    # Case where Freetype is compiled from sources (debug version is compiled by default)
+    SET(FREETYPE_FOUND ON)
+    SET(FREETYPE_LIBRARIES ${FREETYPE_LIBRARY_DEBUG})
+  ENDIF(FREETYPE_LIBRARY_RELEASE AND FREETYPE_LIBRARY_DEBUG)
+ENDIF(FREETYPE_INCLUDE_DIRS)
+
+IF(FREETYPE_FOUND)
   IF(WITH_STATIC_EXTERNAL AND APPLE)
     FIND_PACKAGE(BZip2)
     IF(BZIP2_FOUND)
       SET(FREETYPE_INCLUDE_DIRS ${FREETYPE_INCLUDE_DIRS} ${BZIP2_INCLUDE_DIR})
-      SET(FREETYPE_LIBRARY ${FREETYPE_LIBRARY} ${BZIP2_LIBRARIES})
+      SET(FREETYPE_LIBRARIES ${FREETYPE_LIBRARIES} ${BZIP2_LIBRARIES})
     ENDIF(BZIP2_FOUND)
   ENDIF(WITH_STATIC_EXTERNAL AND APPLE)
-  IF(NOT FREETYPE_FIND_QUIETLY)
+  IF(NOT Freetype_FIND_QUIETLY)
-    MESSAGE(STATUS "Found FreeType: ${FREETYPE_LIBRARY}")
+    MESSAGE(STATUS "Found FreeType: ${FREETYPE_LIBRARIES}")
-  ENDIF(NOT FREETYPE_FIND_QUIETLY)
+  ENDIF(NOT Freetype_FIND_QUIETLY)
 ELSE(FREETYPE_LIBRARY AND FREETYPE_INCLUDE_DIRS)
-  IF(NOT FREETYPE_FIND_QUIETLY)
+  IF(NOT Freetype_FIND_QUIETLY)
     MESSAGE(STATUS "Warning: Unable to find FreeType!")
-  ENDIF(NOT FREETYPE_FIND_QUIETLY)
+  ENDIF(NOT Freetype_FIND_QUIETLY)
-ENDIF(FREETYPE_LIBRARY AND FREETYPE_INCLUDE_DIRS)
+ENDIF(FREETYPE_FOUND)

code/CMakeModules/FindLibOVR.cmake

@@ -0,0 +1,70 @@
+# - Locate LibOVR library
+# This module defines
+#  LIBOVR_LIBRARIES, the libraries to link against
+#  LIBOVR_FOUND, if false, do not try to link to LIBOVR
+#  LIBOVR_INCLUDE_DIR, where to find headers.
+
+IF(LIBOVR_LIBRARIES AND LIBOVR_INCLUDE_DIR)
+  # in cache already
+  SET(LIBOVR_FIND_QUIETLY TRUE)
+ENDIF(LIBOVR_LIBRARIES AND LIBOVR_INCLUDE_DIR)
+
+FIND_PATH(LIBOVR_INCLUDE_DIR
+  OVR.h
+  PATHS
+  $ENV{LIBOVR_DIR}/Include
+  /usr/local/include
+  /usr/include
+  /sw/include
+  /opt/local/include
+  /opt/csw/include
+  /opt/include
+)
+
+IF(UNIX)
+  IF(TARGET_X64)
+    SET(LIBOVR_LIBRARY_BUILD_PATH "Lib/Linux/Release/x86_64")
+  ELSE(TARGET_X64)
+    SET(LIBOVR_LIBRARY_BUILD_PATH "Lib/Linux/Release/i386")
+  ENDIF(TARGET_X64)
+ELSEIF(APPLE)
+  SET(LIBOVR_LIBRARY_BUILD_PATH "Lib/MacOS/Release")
+ELSEIF(WIN32)
+  IF(TARGET_X64)
+    SET(LIBOVR_LIBRARY_BUILD_PATH "Lib/x64")
+  ELSE(TARGET_X64)
+    SET(LIBOVR_LIBRARY_BUILD_PATH "Lib/Win32")
+  ENDIF(TARGET_X64)
+ENDIF(UNIX)
+
+FIND_LIBRARY(LIBOVR_LIBRARY
+  NAMES ovr
+  PATHS
+  $ENV{LIBOVR_DIR}/${LIBOVR_LIBRARY_BUILD_PATH}
+  /usr/local/lib
+  /usr/lib
+  /usr/local/X11R6/lib
+  /usr/X11R6/lib
+  /sw/lib
+  /opt/local/lib
+  /opt/csw/lib
+  /opt/lib
+  /usr/freeware/lib64
+)
+
+IF(LIBOVR_LIBRARY AND LIBOVR_INCLUDE_DIR)
+  IF(NOT LIBOVR_FIND_QUIETLY)
+    MESSAGE(STATUS "Found LibOVR: ${LIBOVR_LIBRARY}")
+  ENDIF(NOT LIBOVR_FIND_QUIETLY)
+  SET(LIBOVR_FOUND "YES")
+  SET(LIBOVR_DEFINITIONS "-DHAVE_LIBOVR")
+  IF(UNIX)
+    SET(LIBOVR_LIBRARIES ${LIBOVR_LIBRARY} X11 Xinerama udev pthread)
+  ELSE(UNIX)
+    SET(LIBOVR_LIBRARIES ${LIBOVR_LIBRARY})
+  ENDIF(UNIX)
+ELSE(LIBOVR_LIBRARY AND LIBOVR_INCLUDE_DIR)
+  IF(NOT LIBOVR_FIND_QUIETLY)
+    MESSAGE(STATUS "Warning: Unable to find LibOVR!")
+  ENDIF(NOT LIBOVR_FIND_QUIETLY)
+ENDIF(LIBOVR_LIBRARY AND LIBOVR_INCLUDE_DIR)

code/CMakeModules/FindLibVR.cmake

@@ -0,0 +1,32 @@
+# - Locate LibVR library
+# This module defines
+#  LIBVR_LIBRARIES, the libraries to link against
+#  LIBVR_FOUND, if false, do not try to link to LIBVR
+#  LIBVR_INCLUDE_DIR, where to find headers.
+
+IF(LIBVR_LIBRARIES AND LIBVR_INCLUDE_DIR)
+  # in cache already
+  SET(LIBVR_FIND_QUIETLY TRUE)
+ENDIF(LIBVR_LIBRARIES AND LIBVR_INCLUDE_DIR)
+
+FIND_PATH(LIBVR_INCLUDE_DIR hmd.h
+  PATH_SUFFIXES include/LibVR
+)
+
+FIND_LIBRARY(LIBVR_LIBRARY
+  NAMES vr
+  PATH_SUFFIXES lib
+  PATHS
+)
+
+IF(LIBVR_LIBRARY AND LIBVR_INCLUDE_DIR)
+  IF(NOT LIBVR_FIND_QUIETLY)
+    MESSAGE(STATUS "Found LibVR: ${LIBVR_LIBRARY}")
+  ENDIF(NOT LIBVR_FIND_QUIETLY)
+  SET(LIBVR_FOUND "YES")
+  SET(LIBVR_DEFINITIONS "-DHAVE_LIBVR")
+ELSE(LIBVR_LIBRARY AND LIBVR_INCLUDE_DIR)
+  IF(NOT LIBVR_FIND_QUIETLY)
+    MESSAGE(STATUS "Warning: Unable to find LibVR!")
+  ENDIF(NOT LIBVR_FIND_QUIETLY)
+ENDIF(LIBVR_LIBRARY AND LIBVR_INCLUDE_DIR)

code/CMakeModules/FindLibwww.cmake

@@ -3,17 +3,15 @@
 #
 # This module defines
 # LIBWWW_INCLUDE_DIR, where to find tiff.h, etc.
-# LIBWWW_LIBRARY, where to find the LibWWW library.
+# LIBWWW_LIBRARY, where to find the Libwww library.
-# LIBWWW_FOUND, If false, do not try to use LibWWW.
+# LIBWWW_FOUND, If false, do not try to use Libwww.
 
 OPTION(WITH_LIBWWW_STATIC "Use only static libraries for libwww" OFF)
 
-SET(LIBWWW_FIND_QUIETLY ${Libwww_FIND_QUIETLY})
-
 # also defined, but not for general use are
 IF(LIBWWW_LIBRARIES AND LIBWWW_INCLUDE_DIR)
   # in cache already
-  SET(LIBWWW_FIND_QUIETLY TRUE)
+  SET(Libwww_FIND_QUIETLY TRUE)
 ENDIF(LIBWWW_LIBRARIES AND LIBWWW_INCLUDE_DIR)
 
 FIND_PATH(LIBWWW_INCLUDE_DIR
@@ -47,14 +45,29 @@ IF(LIBWWW_ADDITIONAL_INCLUDE_DIR)
 ENDIF(LIBWWW_ADDITIONAL_INCLUDE_DIR)
 
 # helper to find all the libwww sub libraries
-MACRO(FIND_WWW_LIBRARY MYLIBRARY OPTION)
+MACRO(FIND_WWW_LIBRARY MYLIBRARY OPTION FILE)
   IF(WITH_LIBWWW_STATIC AND UNIX AND NOT APPLE AND NOT WITH_STATIC_EXTERNAL)
     SET(CMAKE_FIND_LIBRARY_SUFFIXES_OLD ${CMAKE_FIND_LIBRARY_SUFFIXES})
     SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
   ENDIF(WITH_LIBWWW_STATIC AND UNIX AND NOT APPLE AND NOT WITH_STATIC_EXTERNAL)
 
-  FIND_LIBRARY(${MYLIBRARY}
+  FIND_LIBRARY(${MYLIBRARY}_RELEASE
-    NAMES ${ARGN}
+    NAMES ${FILE}
+    PATHS
+    /usr/local/lib
+    /usr/lib
+    /usr/lib/x86_64-linux-gnu
+    /usr/local/X11R6/lib
+    /usr/X11R6/lib
+    /sw/lib
+    /opt/local/lib
+    /opt/csw/lib
+    /opt/lib
+    /usr/freeware/lib64
+  )
+
+  FIND_LIBRARY(${MYLIBRARY}_DEBUG
+    NAMES ${FILE}d
     PATHS
     /usr/local/lib
     /usr/lib
@@ -72,17 +85,25 @@ MACRO(FIND_WWW_LIBRARY MYLIBRARY OPTION)
     SET(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_OLD})
   ENDIF(CMAKE_FIND_LIBRARY_SUFFIXES_OLD)
 
-  IF(${MYLIBRARY})
+  IF(${MYLIBRARY}_RELEASE AND ${MYLIBRARY}_DEBUG)
     IF(${OPTION} STREQUAL REQUIRED OR WITH_STATIC OR WITH_LIBWWW_STATIC)
-      SET(LIBWWW_LIBRARIES ${LIBWWW_LIBRARIES} ${${MYLIBRARY}})
+      SET(LIBWWW_LIBRARIES ${LIBWWW_LIBRARIES} optimized ${${MYLIBRARY}_RELEASE} debug ${${MYLIBRARY}_DEBUG})
     ENDIF(${OPTION} STREQUAL REQUIRED OR WITH_STATIC OR WITH_LIBWWW_STATIC)
-  ELSE(${MYLIBRARY})
+  ELSEIF(${MYLIBRARY}_RELEASE)
-    IF(NOT LIBWWW_FIND_QUIETLY AND NOT WIN32)
+    IF(${OPTION} STREQUAL REQUIRED OR WITH_STATIC OR WITH_LIBWWW_STATIC)
+      SET(LIBWWW_LIBRARIES ${LIBWWW_LIBRARIES} ${${MYLIBRARY}_RELEASE})
+    ENDIF(${OPTION} STREQUAL REQUIRED OR WITH_STATIC OR WITH_LIBWWW_STATIC)
+  ELSEIF(${MYLIBRARY}_DEBUG)
+    IF(${OPTION} STREQUAL REQUIRED OR WITH_STATIC OR WITH_LIBWWW_STATIC)
+      SET(LIBWWW_LIBRARIES ${LIBWWW_LIBRARIES} ${${MYLIBRARY}_DEBUG})
+    ENDIF(${OPTION} STREQUAL REQUIRED OR WITH_STATIC OR WITH_LIBWWW_STATIC)
+  ELSE(${MYLIBRARY}_RELEASE AND ${MYLIBRARY}_DEBUG)
+    IF(NOT Libwww_FIND_QUIETLY AND NOT WIN32)
       MESSAGE(STATUS "Warning: Libwww: Library not found: ${MYLIBRARY}")
-    ENDIF(NOT LIBWWW_FIND_QUIETLY AND NOT WIN32)
+    ENDIF(NOT Libwww_FIND_QUIETLY AND NOT WIN32)
-  ENDIF(${MYLIBRARY})
+  ENDIF(${MYLIBRARY}_RELEASE AND ${MYLIBRARY}_DEBUG)
 
-  MARK_AS_ADVANCED(${MYLIBRARY})
+  MARK_AS_ADVANCED(${MYLIBRARY}_RELEASE ${MYLIBRARY}_DEBUG)
 ENDMACRO(FIND_WWW_LIBRARY)
 
 MACRO(LINK_WWW_LIBRARY MYLIBRARY OTHERLIBRARY SYMBOL)
@@ -163,7 +184,7 @@ LINK_WWW_LIBRARY(LIBWWWAPP_LIBRARY LIBREGEX_LIBRARY regexec)
 LINK_WWW_LIBRARY(LIBWWWAPP_LIBRARY OPENSSL_LIBRARIES SSL_new)
 
 INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibWWW DEFAULT_MSG
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Libwww DEFAULT_MSG
   LIBWWW_LIBRARIES
   LIBWWW_INCLUDE_DIR
 )

code/CMakeModules/FindLua52.cmake

@@ -0,0 +1,81 @@
+# Locate Lua library
+# This module defines
+#  LUA52_FOUND, if false, do not try to link to Lua
+#  LUA_LIBRARIES
+#  LUA_INCLUDE_DIR, where to find lua.h
+#  LUA_VERSION_STRING, the version of Lua found (since CMake 2.8.8)
+#
+# Note that the expected include convention is
+#  #include "lua.h"
+# and not
+#  #include <lua/lua.h>
+# This is because, the lua location is not standardized and may exist
+# in locations other than lua/
+
+#=============================================================================
+# Copyright 2007-2009 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+find_path(LUA_INCLUDE_DIR lua.h
+  HINTS
+    ENV LUA_DIR
+  PATH_SUFFIXES include/lua52 include/lua5.2 include/lua-5.2 include/lua include
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /sw # Fink
+  /opt/local # DarwinPorts
+  /opt/csw # Blastwave
+  /opt
+)
+
+find_library(LUA_LIBRARY
+  NAMES lua52 lua5.2 lua-5.2 lua
+  HINTS
+    ENV LUA_DIR
+  PATH_SUFFIXES lib
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /sw
+  /opt/local
+  /opt/csw
+  /opt
+)
+
+if(LUA_LIBRARY)
+  # include the math library for Unix
+  if(UNIX AND NOT APPLE AND NOT BEOS)
+    find_library(LUA_MATH_LIBRARY m)
+    set( LUA_LIBRARIES "${LUA_LIBRARY};${LUA_MATH_LIBRARY}" CACHE STRING "Lua Libraries")
+  # For Windows and Mac, don't need to explicitly include the math library
+  else()
+    set( LUA_LIBRARIES "${LUA_LIBRARY}" CACHE STRING "Lua Libraries")
+  endif()
+endif()
+
+if(LUA_INCLUDE_DIR AND EXISTS "${LUA_INCLUDE_DIR}/lua.h")
+  file(STRINGS "${LUA_INCLUDE_DIR}/lua.h" lua_version_str REGEX "^#define[ \t]+LUA_RELEASE[ \t]+\"Lua .+\"")
+
+  string(REGEX REPLACE "^#define[ \t]+LUA_RELEASE[ \t]+\"Lua ([^\"]+)\".*" "\\1" LUA_VERSION_STRING "${lua_version_str}")
+  unset(lua_version_str)
+endif()
+
+include(FindPackageHandleStandardArgs)
+# handle the QUIETLY and REQUIRED arguments and set LUA_FOUND to TRUE if
+# all listed variables are TRUE
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Lua52
+                                  REQUIRED_VARS LUA_LIBRARIES LUA_INCLUDE_DIR
+                                  VERSION_VAR LUA_VERSION_STRING)
+
+mark_as_advanced(LUA_INCLUDE_DIR LUA_LIBRARIES LUA_LIBRARY LUA_MATH_LIBRARY)
+

code/CMakeModules/FindLuabind.cmake

@@ -4,6 +4,48 @@
 #  LUABIND_FOUND, if false, do not try to link to LUABIND
 #  LUABIND_INCLUDE_DIR, where to find headers.
 
+MACRO(FIND_CORRECT_LUA_VERSION)
+  # Check Lua version linked to Luabind under Linux
+  IF(LUABIND_LIBRARY_RELEASE MATCHES "\\.so")
+    INCLUDE(CheckDepends)
+
+    SET(LUA52_LIBRARY "liblua5.2")
+    CHECK_LINKED_LIBRARY(LUABIND_LIBRARY_RELEASE LUA52_LIBRARY LUALIB_FOUND)
+
+    IF(LUALIB_FOUND)
+      MESSAGE(STATUS "Luabind is using Lua 5.2")
+      FIND_PACKAGE(Lua52 REQUIRED)
+    ELSE(LUALIB_FOUND)
+      SET(LUA51_LIBRARY "liblua5.1")
+      CHECK_LINKED_LIBRARY(LUABIND_LIBRARY_RELEASE LUA51_LIBRARY LUALIB_FOUND)
+
+      IF(LUALIB_FOUND)
+        MESSAGE(STATUS "Luabind is using Lua 5.1")
+        FIND_PACKAGE(Lua51 REQUIRED)
+      ELSE(LUALIB_FOUND)
+        SET(LUA50_LIBRARY "liblua5.0")
+        CHECK_LINKED_LIBRARY(LUABIND_LIBRARY_RELEASE LUA50_LIBRARY LUALIB_FOUND)
+
+        IF(LUALIB_FOUND)
+          MESSAGE(STATUS "Luabind is using Lua 5.0")
+          FIND_PACKAGE(Lua50 REQUIRED)
+        ELSE(LUALIB_FOUND)
+          MESSAGE(FATAL_ERROR "Can't determine Lua version used by Luabind")
+        ENDIF(LUALIB_FOUND)
+      ENDIF(LUALIB_FOUND)
+    ENDIF(LUALIB_FOUND)
+  ELSE(LUABIND_LIBRARY_RELEASE MATCHES "\\.so")
+    # TODO: find a way to detect Lua version
+    IF(WITH_LUA52)
+      FIND_PACKAGE(Lua52 REQUIRED)
+    ELSEIF(WITH_LUA51)
+      FIND_PACKAGE(Lua51 REQUIRED)
+    ELSE(WITH_LUA52)
+      FIND_PACKAGE(Lua50 REQUIRED)
+    ENDIF(WITH_LUA52)
+  ENDIF(LUABIND_LIBRARY_RELEASE MATCHES "\\.so")
+ENDMACRO(FIND_CORRECT_LUA_VERSION)
+
 IF(LUABIND_LIBRARIES AND LUABIND_INCLUDE_DIR)
   # in cache already
   SET(Luabind_FIND_QUIETLY TRUE)
@@ -84,6 +126,9 @@ IF(LUABIND_FOUND)
   IF(LUABIND_VERSION_FILE)
     SET(LUABIND_DEFINITIONS "-DHAVE_LUABIND_VERSION")
   ENDIF(LUABIND_VERSION_FILE)
+
+  FIND_CORRECT_LUA_VERSION()
+
   IF(NOT Luabind_FIND_QUIETLY)
     MESSAGE(STATUS "Found Luabind: ${LUABIND_LIBRARIES}")
   ENDIF(NOT Luabind_FIND_QUIETLY)

code/CMakeModules/FindMSVC.cmake

@@ -0,0 +1,76 @@
+# - Find MS Visual C++
+#
+#  VC_INCLUDE_DIR  - where to find headers
+#  VC_INCLUDE_DIRS - where to find headers
+#  VC_LIBRARY_DIR  - where to find libraries
+#  VC_FOUND        - True if MSVC found.
+
+MACRO(DETECT_VC_VERSION_HELPER _ROOT _VERSION)
+  # Software/Wow6432Node/...
+  GET_FILENAME_COMPONENT(VC${_VERSION}_DIR "[${_ROOT}\\SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VC7;${_VERSION}]" ABSOLUTE)
+
+  IF(VC${_VERSION}_DIR AND VC${_VERSION}_DIR STREQUAL "/registry")
+    SET(VC${_VERSION}_DIR)
+    GET_FILENAME_COMPONENT(VC${_VERSION}_DIR "[${_ROOT}\\SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VS7;${_VERSION}]" ABSOLUTE)
+    IF(VC${_VERSION}_DIR AND NOT VC${_VERSION}_DIR STREQUAL "/registry")
+      SET(VC${_VERSION}_DIR "${VC${_VERSION}_DIR}VC/")
+    ENDIF(VC${_VERSION}_DIR AND NOT VC${_VERSION}_DIR STREQUAL "/registry")
+  ENDIF(VC${_VERSION}_DIR AND VC${_VERSION}_DIR STREQUAL "/registry")
+
+  IF(VC${_VERSION}_DIR AND NOT VC${_VERSION}_DIR STREQUAL "/registry")
+    SET(VC${_VERSION}_FOUND ON)
+    IF(NOT MSVC_FIND_QUIETLY)
+      MESSAGE(STATUS "Found Visual C++ ${_VERSION} in ${VC${_VERSION}_DIR}")
+    ENDIF(NOT MSVC_FIND_QUIETLY)
+  ELSEIF(VC${_VERSION}_DIR AND NOT VC${_VERSION}_DIR STREQUAL "/registry")
+    SET(VC${_VERSION}_FOUND OFF)
+    SET(VC${_VERSION}_DIR "")
+  ENDIF(VC${_VERSION}_DIR AND NOT VC${_VERSION}_DIR STREQUAL "/registry")
+ENDMACRO(DETECT_VC_VERSION_HELPER)
+
+MACRO(DETECT_VC_VERSION _VERSION)
+  SET(VC${_VERSION}_FOUND OFF)
+  DETECT_VC_VERSION_HELPER("HKEY_CURRENT_USER" ${_VERSION})
+
+  IF(NOT VC${_VERSION}_FOUND)
+    DETECT_VC_VERSION_HELPER("HKEY_LOCAL_MACHINE" ${_VERSION})
+  ENDIF(NOT VC${_VERSION}_FOUND)
+
+  IF(VC${_VERSION}_FOUND)
+    SET(VC_FOUND ON)
+    SET(VC_DIR "${VC${_VERSION}_DIR}")
+  ENDIF(VC${_VERSION}_FOUND)
+ENDMACRO(DETECT_VC_VERSION)
+
+IF(MSVC11)
+  DETECT_VC_VERSION("11.0")
+
+  IF(NOT MSVC11_REDIST_DIR)
+    # If you have VC++ 2012 Express, put x64/Microsoft.VC110.CRT/*.dll in ${EXTERNAL_PATH}/redist
+    SET(MSVC11_REDIST_DIR "${EXTERNAL_PATH}/redist")
+  ENDIF(NOT MSVC11_REDIST_DIR)
+ELSEIF(MSVC10)
+  DETECT_VC_VERSION("10.0")
+
+  IF(NOT MSVC10_REDIST_DIR)
+    # If you have VC++ 2010 Express, put x64/Microsoft.VC100.CRT/*.dll in ${EXTERNAL_PATH}/redist
+    SET(MSVC10_REDIST_DIR "${EXTERNAL_PATH}/redist")
+  ENDIF(NOT MSVC10_REDIST_DIR)
+ELSEIF(MSVC90)
+  DETECT_VC_VERSION("9.0")
+ELSEIF(MSVC80)
+  DETECT_VC_VERSION("8.0")
+ENDIF(MSVC11)
+
+# If you plan to use VC++ compilers with WINE, set VC_DIR environment variable
+IF(NOT VC_DIR)
+  SET(VC_DIR $ENV{VC_DIR})
+ENDIF(NOT VC_DIR)
+
+IF(NOT VC_DIR)
+  STRING(REGEX REPLACE "/bin/.+" "" VC_DIR ${CMAKE_CXX_COMPILER})
+ENDIF(NOT VC_DIR)
+
+SET(VC_INCLUDE_DIR "${VC_DIR}/include")
+SET(VC_INCLUDE_DIRS ${VC_INCLUDE_DIR})
+INCLUDE_DIRECTORIES(${VC_INCLUDE_DIR})

code/CMakeModules/FindMercurial.cmake

@@ -48,7 +48,8 @@
 #  License text for the above reference.)
 
 FIND_PROGRAM(Mercurial_HG_EXECUTABLE hg
-  DOC "mercurial command line client")
+  DOC "mercurial command line client"
+  HINTS /opt/local/bin)
 MARK_AS_ADVANCED(Mercurial_HG_EXECUTABLE)
 
 IF(Mercurial_HG_EXECUTABLE)

code/CMakeModules/FindMySQL.cmake

@@ -58,6 +58,8 @@ ELSE(MYSQL_INCLUDE_DIR AND MYSQL_LIBRARIES)
       SET(MYSQL_LIBRARIES optimized ${MYSQL_LIBRARY_RELEASE})
       IF(MYSQL_LIBRARY_DEBUG)
         SET(MYSQL_LIBRARIES ${MYSQL_LIBRARIES} debug ${MYSQL_LIBRARY_DEBUG})
+      ELSE(MYSQL_LIBRARY_DEBUG)
+	    SET(MYSQL_LIBRARIES ${MYSQL_LIBRARIES} debug ${MYSQL_LIBRARY_RELEASE})
       ENDIF(MYSQL_LIBRARY_DEBUG)
       FIND_PACKAGE(OpenSSL)
       IF(OPENSSL_FOUND)

code/CMakeModules/FindS3TC.cmake

@@ -1,50 +0,0 @@
-# - Locate S3TC library
-# This module defines
-#  S3TC_LIBRARY, the library to link against
-#  S3TC_FOUND, if false, do not try to link to S3TC
-#  S3TC_INCLUDE_DIR, where to find headers.
-
-IF(S3TC_LIBRARY AND S3TC_INCLUDE_DIR)
-  # in cache already
-  SET(S3TC_FIND_QUIETLY TRUE)
-ENDIF(S3TC_LIBRARY AND S3TC_INCLUDE_DIR)
-
-
-FIND_PATH(S3TC_INCLUDE_DIR
-  s3_intrf.h
-  PATHS
-  $ENV{S3TC_DIR}/include
-  /usr/local/include
-  /usr/include
-  /sw/include
-  /opt/local/include
-  /opt/csw/include
-  /opt/include
-  PATH_SUFFIXES S3TC
-)
-
-FIND_LIBRARY(S3TC_LIBRARY
-  NAMES s3tc libs3tc
-  PATHS
-  $ENV{S3TC_DIR}/lib
-  /usr/local/lib
-  /usr/lib
-  /usr/local/X11R6/lib
-  /usr/X11R6/lib
-  /sw/lib
-  /opt/local/lib
-  /opt/csw/lib
-  /opt/lib
-  /usr/freeware/lib64
-)
-
-IF(S3TC_LIBRARY AND S3TC_INCLUDE_DIR)
-  SET(S3TC_FOUND "YES")
-  IF(NOT S3TC_FIND_QUIETLY)
-    MESSAGE(STATUS "Found S3TC: ${S3TC_LIBRARY}")
-  ENDIF(NOT S3TC_FIND_QUIETLY)
-ELSE(S3TC_LIBRARY AND S3TC_INCLUDE_DIR)
-  IF(NOT S3TC_FIND_QUIETLY)
-    MESSAGE(STATUS "Warning: Unable to find S3TC!")
-  ENDIF(NOT S3TC_FIND_QUIETLY)
-ENDIF(S3TC_LIBRARY AND S3TC_INCLUDE_DIR)

code/CMakeModules/FindWindowsSDK.cmake

@@ -6,80 +6,163 @@
 #  WINSDK_LIBRARY_DIR - where to find libraries
 #  WINSDK_FOUND       - True if Windows SDK found.
 
-IF(WINSDK_INCLUDE_DIR)
+IF(WINSDK_FOUND)
-    # Already in cache, be silent
+  # If Windows SDK already found, skip it
-    SET(WindowsSDK_FIND_QUIETLY TRUE)
+  RETURN()
-ENDIF(WINSDK_INCLUDE_DIR)
+ENDIF(WINSDK_FOUND)
 
-# TODO: add the possibility to use a specific Windows SDK
+SET(WINSDK_VERSION "CURRENT" CACHE STRING "Windows SDK version to prefer")
 
-IF(MSVC11)
+MACRO(DETECT_WINSDK_VERSION_HELPER _ROOT _VERSION)
-  GET_FILENAME_COMPONENT(WINSDK8_DIR  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v8.0;InstallationFolder]" ABSOLUTE CACHE)
+  GET_FILENAME_COMPONENT(WINSDK${_VERSION}_DIR "[${_ROOT}\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v${_VERSION};InstallationFolder]" ABSOLUTE)
-  GET_FILENAME_COMPONENT(WINSDK8_VERSION "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v8.0;ProductVersion]" NAME)
 
-  IF(WINSDK8_DIR)
+  IF(WINSDK${_VERSION}_DIR AND NOT WINSDK${_VERSION}_DIR STREQUAL "/registry")
+    SET(WINSDK${_VERSION}_FOUND ON)
+    GET_FILENAME_COMPONENT(WINSDK${_VERSION}_VERSION_FULL "[${_ROOT}\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v${_VERSION};ProductVersion]" NAME)
     IF(NOT WindowsSDK_FIND_QUIETLY)
-      MESSAGE(STATUS "Found Windows SDK ${WINSDK8_VERSION} in ${WINSDK8_DIR}")
+      MESSAGE(STATUS "Found Windows SDK ${_VERSION} in ${WINSDK${_VERSION}_DIR}")
     ENDIF(NOT WindowsSDK_FIND_QUIETLY)
+  ELSEIF(WINSDK${_VERSION}_DIR AND NOT WINSDK${_VERSION}_DIR STREQUAL "/registry")
+    SET(WINSDK${_VERSION}_DIR "")
+  ENDIF(WINSDK${_VERSION}_DIR AND NOT WINSDK${_VERSION}_DIR STREQUAL "/registry")
+ENDMACRO(DETECT_WINSDK_VERSION_HELPER)
+
+MACRO(DETECT_WINSDK_VERSION _VERSION)
+  SET(WINSDK${_VERSION}_FOUND OFF)
+  DETECT_WINSDK_VERSION_HELPER("HKEY_CURRENT_USER" ${_VERSION})
+  
+  IF(NOT WINSDK${_VERSION}_FOUND)
+    DETECT_WINSDK_VERSION_HELPER("HKEY_LOCAL_MACHINE" ${_VERSION})
+  ENDIF(NOT WINSDK${_VERSION}_FOUND)
+ENDMACRO(DETECT_WINSDK_VERSION)
+
+SET(WINSDK_VERSIONS "8.0" "8.0A" "7.1" "7.0A" "6.1" "6.0" "6.0A")
+
+# Search all supported Windows SDKs
+FOREACH(_VERSION ${WINSDK_VERSIONS})
+  DETECT_WINSDK_VERSION(${_VERSION})
+ENDFOREACH(_VERSION)
+
+SET(WINSDK_SUFFIX)
+
 IF(TARGET_ARM)
   SET(WINSDK8_SUFFIX "arm")
 ELSEIF(TARGET_X64)
   SET(WINSDK8_SUFFIX "x64")
+  SET(WINSDK_SUFFIX "x64")
 ELSEIF(TARGET_X86)
   SET(WINSDK8_SUFFIX "x86")
 ENDIF(TARGET_ARM)
-  ENDIF(WINSDK8_DIR)
-ENDIF(MSVC11)
 
-GET_FILENAME_COMPONENT(WINSDK71_DIR  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v7.1;InstallationFolder]" ABSOLUTE CACHE)
-GET_FILENAME_COMPONENT(WINSDK71_VERSION "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v7.1;ProductVersion]" NAME)
-
-IF(WINSDK71_DIR)
-  IF(NOT WindowsSDK_FIND_QUIETLY)
-    MESSAGE(STATUS "Found Windows SDK ${WINSDK71_VERSION} in ${WINSDK71_DIR}")
-  ENDIF(NOT WindowsSDK_FIND_QUIETLY)
-ENDIF(WINSDK71_DIR)
-
-GET_FILENAME_COMPONENT(WINSDKCURRENT_DIR  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows;CurrentInstallFolder]" ABSOLUTE CACHE)
 GET_FILENAME_COMPONENT(WINSDKCURRENT_VERSION "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows;CurrentVersion]" NAME)
 
-IF(WINSDKCURRENT_DIR)
+IF(WINSDKCURRENT_VERSION AND NOT WINSDKCURRENT_VERSION STREQUAL "/registry")
   IF(NOT WindowsSDK_FIND_QUIETLY)
-    MESSAGE(STATUS "Found Windows SDK ${WINSDKCURRENT_VERSION} in ${WINSDKCURRENT_DIR}")
+#    MESSAGE(STATUS "Current version is ${WINSDKCURRENT_VERSION}")
   ENDIF(NOT WindowsSDK_FIND_QUIETLY)
-ENDIF(WINSDKCURRENT_DIR)
+ENDIF(WINSDKCURRENT_VERSION AND NOT WINSDKCURRENT_VERSION STREQUAL "/registry")
 
+SET(WINSDKENV_DIR $ENV{WINSDK_DIR})
+
+MACRO(USE_CURRENT_WINSDK)
+  IF(WINSDKENV_DIR)
+    SET(WINSDK_VERSION "")
+    SET(WINSDK_VERSION_FULL "")
+    SET(WINSDK_DIR ${WINSDKENV_DIR})
+    FOREACH(_VERSION ${WINSDK_VERSIONS})
+      IF(WINSDK_DIR STREQUAL WINSDK${_VERSION}_DIR)
+        SET(WINSDK_VERSION ${_VERSION})
+        SET(WINSDK_VERSION_FULL "${WINSDK${_VERSION}_VERSION_FULL}")
+        BREAK()
+      ENDIF(WINSDK_DIR STREQUAL WINSDK${_VERSION}_DIR)
+    ENDFOREACH(_VERSION)
+  ELSE(WINSDKENV_DIR)
+    # Windows SDK 7.0A doesn't provide 64bits compilers, use SDK 7.1 for 64 bits
+    IF(WINSDKCURRENT_VERSION STREQUAL WINSDK7.0A_VERSION_FULL)
+      IF(TARGET_X64)
+        SET(WINSDK_VERSION "7.1")
+        SET(WINSDK_VERSION_FULL ${WINSDK7.1_VERSION_FULL})
+        SET(WINSDK_DIR ${WINSDK7.1_DIR})
+      ELSE(TARGET_X64)
+        SET(WINSDK_VERSION "7.0A")
+        SET(WINSDK_VERSION_FULL ${WINSDK7.0A_VERSION_FULL})
+        SET(WINSDK_DIR ${WINSDK7.0A_DIR})
+      ENDIF(TARGET_X64)
+    ELSE(WINSDKCURRENT_VERSION STREQUAL WINSDK7.0A_VERSION_FULL)
+      FOREACH(_VERSION ${WINSDK_VERSIONS})
+        IF(WINSDKCURRENT_VERSION STREQUAL WINSDK${_VERSION}_VERSION)
+          SET(WINSDK_VERSION ${_VERSION})
+          SET(WINSDK_VERSION_FULL "${WINSDK${_VERSION}_VERSION_FULL}")
+          SET(WINSDK_DIR "${WINSDK${_VERSION}_DIR}")
+          BREAK()
+        ENDIF(WINSDKCURRENT_VERSION STREQUAL WINSDK${_VERSION}_VERSION)
+      ENDFOREACH(_VERSION)
+    ENDIF(WINSDKCURRENT_VERSION STREQUAL WINSDK7.0A_VERSION_FULL)
+  ENDIF(WINSDKENV_DIR)
+ENDMACRO(USE_CURRENT_WINSDK)
+
+IF(WINSDK_VERSION STREQUAL "CURRENT")
+  USE_CURRENT_WINSDK()
+ELSE(WINSDK_VERSION STREQUAL "CURRENT")
+  IF(WINSDK${WINSDK_VERSION}_FOUND)
+    SET(WINSDK_VERSION_FULL "${WINSDK${WINSDK_VERSION}_VERSION_FULL}")
+    SET(WINSDK_DIR "${WINSDK${WINSDK_VERSION}_DIR}")
+  ELSE(WINSDK${WINSDK_VERSION}_FOUND)
+    USE_CURRENT_WINSDK()
+  ENDIF(WINSDK${WINSDK_VERSION}_FOUND)
+ENDIF(WINSDK_VERSION STREQUAL "CURRENT")
+
+IF(WINSDK_DIR)
+  MESSAGE(STATUS "Using Windows SDK ${WINSDK_VERSION}")
+ELSE(WINSDK_DIR)
+  MESSAGE(FATAL_ERROR "Unable to find Windows SDK!")
+ENDIF(WINSDK_DIR)
+
+# directory where Win32 headers are found
 FIND_PATH(WINSDK_INCLUDE_DIR Windows.h
   HINTS
-  ${WINSDK8_DIR}/Include/um
+  ${WINSDK_DIR}/Include/um
-  ${WINSDK71_DIR}/Include
+  ${WINSDK_DIR}/Include
-  ${WINSDKCURRENT_DIR}/Include
 )
 
+# directory where DirectX headers are found
 FIND_PATH(WINSDK_SHARED_INCLUDE_DIR d3d9.h
   HINTS
-  ${WINSDK8_DIR}/Include/shared
+  ${WINSDK_DIR}/Include/shared
-  ${WINSDK71_DIR}/Include
+  ${WINSDK_DIR}/Include
-  ${WINSDKCURRENT_DIR}/Include
 )
 
+# directory where all libraries are found
 FIND_PATH(WINSDK_LIBRARY_DIR ComCtl32.lib
   HINTS
-  ${WINSDK8_DIR}/Lib/win8/um/${WINSDK8_SUFFIX}
+  ${WINSDK_DIR}/Lib/win8/um/${WINSDK8_SUFFIX}
-  ${WINSDK71_DIR}/Lib
+  ${WINSDK_DIR}/Lib/${WINSDK_SUFFIX}
-  ${WINSDKCURRENT_DIR}/Lib
 )
 
+# signtool is used to sign executables
 FIND_PROGRAM(WINSDK_SIGNTOOL signtool
   HINTS
-  ${WINSDK8_DIR}/Bin/x86
+  ${WINSDK_DIR}/Bin/x86
-  ${WINSDK71_DIR}/Bin
+  ${WINSDK_DIR}/Bin
-  ${WINSDKCURRENT_DIR}/Bin
+)
+
+# midl is used to generate IDL interfaces
+FIND_PROGRAM(WINSDK_MIDL midl
+  HINTS
+  ${WINSDK_DIR}/Bin/x86
+  ${WINSDK_DIR}/Bin
 )
 
 IF(WINSDK_INCLUDE_DIR)
-  SET(WINSDK_FOUND TRUE)
+  SET(WINSDK_FOUND ON)
   SET(WINSDK_INCLUDE_DIRS ${WINSDK_INCLUDE_DIR} ${WINSDK_SHARED_INCLUDE_DIR})
+  SET(CMAKE_LIBRARY_PATH ${WINSDK_LIBRARY_DIR} ${CMAKE_LIBRARY_PATH})
+  INCLUDE_DIRECTORIES(${WINSDK_INCLUDE_DIRS})
+
+  # Fix for using Windows SDK 7.1 with Visual C++ 2012
+  IF(WINSDK_VERSION STREQUAL "7.1" AND MSVC11)
+    ADD_DEFINITIONS(-D_USING_V110_SDK71_)
+  ENDIF(WINSDK_VERSION STREQUAL "7.1" AND MSVC11)
 ELSE(WINSDK_INCLUDE_DIR)
   IF(NOT WindowsSDK_FIND_QUIETLY)
     MESSAGE(STATUS "Warning: Unable to find Windows SDK!")

code/CMakeModules/GetRevision.cmake

@@ -19,6 +19,7 @@ IF(SOURCE_DIR)
     SET(SOURCE_DIR ${ROOT_DIR})
   ENDIF(NOT SOURCE_DIR AND ROOT_DIR)
 ELSE(SOURCE_DIR)
+  SET(SOURCE_DIR ${CMAKE_SOURCE_DIR})
   SET(ROOT_DIR ${CMAKE_SOURCE_DIR})
 ENDIF(SOURCE_DIR)
 
@@ -57,6 +58,15 @@ IF(EXISTS "${ROOT_DIR}/.hg/")
   ENDIF(MERCURIAL_FOUND)
 ENDIF(EXISTS "${ROOT_DIR}/.hg/")
 
+# if processing exported sources, use "revision" file if exists
+IF(SOURCE_DIR AND NOT DEFINED REVISION)
+  SET(REVISION_FILE ${SOURCE_DIR}/revision)
+  IF(EXISTS ${REVISION_FILE})
+    FILE(STRINGS ${REVISION_FILE} REVISION LIMIT_COUNT 1)
+    MESSAGE(STATUS "Read revision ${REVISION} from file")
+  ENDIF(EXISTS ${REVISION_FILE})
+ENDIF(SOURCE_DIR AND NOT DEFINED REVISION)
+
 IF(SOURCE_DIR AND DEFINED REVISION)
   IF(EXISTS ${SOURCE_DIR}/revision.h.in)
     MESSAGE(STATUS "Revision: ${REVISION}")

code/CMakeModules/PCHSupport.cmake

@@ -10,7 +10,6 @@
 
 IF(MSVC)
   SET(PCHSupport_FOUND TRUE)
-  SET(_PCH_include_prefix "/I")
 ELSE(MSVC)
   IF(CMAKE_COMPILER_IS_GNUCXX)
     EXEC_PROGRAM(${CMAKE_CXX_COMPILER}
@@ -26,44 +25,50 @@ ELSE(MSVC)
     # TODO: make tests for other compilers than GCC
     SET(PCHSupport_FOUND TRUE)
   ENDIF(CMAKE_COMPILER_IS_GNUCXX)
-
-  SET(_PCH_include_prefix "-I")
 ENDIF(MSVC)
 
 # Set PCH_FLAGS for common flags, PCH_ARCH_XXX_FLAGS for specific archs flags and PCH_ARCHS for archs
 MACRO(PCH_SET_COMPILE_FLAGS _target)
   SET(PCH_FLAGS)
   SET(PCH_ARCHS)
-  SET(_FLAGS)
 
+  SET(_FLAGS)
   LIST(APPEND _FLAGS ${CMAKE_CXX_FLAGS})
 
   STRING(TOUPPER "${CMAKE_BUILD_TYPE}" _UPPER_BUILD)
   LIST(APPEND _FLAGS " ${CMAKE_CXX_FLAGS_${_UPPER_BUILD}}")
 
-  IF(NOT MSVC)
   GET_TARGET_PROPERTY(_targetType ${_target} TYPE)
+
   IF(${_targetType} STREQUAL SHARED_LIBRARY OR ${_targetType} STREQUAL MODULE_LIBRARY)
-      LIST(APPEND _FLAGS " -fPIC")
+    LIST(APPEND _FLAGS " ${CMAKE_SHARED_LIBRARY_CXX_FLAGS}")
+  ELSE(${_targetType} STREQUAL SHARED_LIBRARY OR ${_targetType} STREQUAL MODULE_LIBRARY)
+    GET_TARGET_PROPERTY(_pic ${_target} POSITION_INDEPENDENT_CODE)
+    IF(_pic)
+      LIST(APPEND _FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_PIE}")
+    ENDIF(_pic)
   ENDIF(${_targetType} STREQUAL SHARED_LIBRARY OR ${_targetType} STREQUAL MODULE_LIBRARY)
-  ENDIF(NOT MSVC)
 
   GET_DIRECTORY_PROPERTY(DIRINC INCLUDE_DIRECTORIES)
   FOREACH(item ${DIRINC})
-    LIST(APPEND _FLAGS " ${_PCH_include_prefix}\"${item}\"")
+    LIST(APPEND _FLAGS " -I\"${item}\"")
   ENDFOREACH(item)
 
   # Required for CMake 2.6
   SET(GLOBAL_DEFINITIONS)
   GET_DIRECTORY_PROPERTY(DEFINITIONS COMPILE_DEFINITIONS)
+  IF(DEFINITIONS)
     FOREACH(item ${DEFINITIONS})
       LIST(APPEND GLOBAL_DEFINITIONS " -D${item}")
     ENDFOREACH(item)
+  ENDIF(DEFINITIONS)
 
   GET_DIRECTORY_PROPERTY(DEFINITIONS COMPILE_DEFINITIONS_${_UPPER_BUILD})
+  IF(DEFINITIONS)
     FOREACH(item ${DEFINITIONS})
       LIST(APPEND GLOBAL_DEFINITIONS " -D${item}")
     ENDFOREACH(item)
+  ENDIF(DEFINITIONS)
 
   GET_TARGET_PROPERTY(oldProps ${_target} COMPILE_FLAGS)
   IF(oldProps)
@@ -75,6 +80,27 @@ MACRO(PCH_SET_COMPILE_FLAGS _target)
     LIST(APPEND _FLAGS " ${oldPropsBuild}")
   ENDIF(oldPropsBuild)
 
+  GET_TARGET_PROPERTY(DIRINC ${_target} INCLUDE_DIRECTORIES)
+  IF(DIRINC)
+    FOREACH(item ${DIRINC})
+      LIST(APPEND _FLAGS " -I\"${item}\"")
+    ENDFOREACH(item)
+  ENDIF(DIRINC)
+
+  GET_TARGET_PROPERTY(DEFINITIONS ${_target} COMPILE_DEFINITIONS)
+  IF(DEFINITIONS)
+    FOREACH(item ${DEFINITIONS})
+      LIST(APPEND GLOBAL_DEFINITIONS " -D${item}")
+    ENDFOREACH(item)
+  ENDIF(DEFINITIONS)
+
+  GET_TARGET_PROPERTY(DEFINITIONS ${_target} COMPILE_DEFINITIONS_${_UPPER_BUILD})
+  IF(DEFINITIONS)
+    FOREACH(item ${DEFINITIONS})
+      LIST(APPEND GLOBAL_DEFINITIONS " -D${item}")
+    ENDFOREACH(item)
+  ENDIF(DEFINITIONS)
+
   GET_DIRECTORY_PROPERTY(_directory_flags DEFINITIONS)
   GET_DIRECTORY_PROPERTY(_directory_definitions DIRECTORY ${CMAKE_SOURCE_DIR} DEFINITIONS)
   LIST(APPEND _FLAGS " ${GLOBAL_DEFINITIONS}")
@@ -90,7 +116,6 @@ MACRO(PCH_SET_COMPILE_FLAGS _target)
     SEPARATE_ARGUMENTS(_FLAGS)
   ENDIF(MSVC)
 
-
   IF(CLANG)
     # Determining all architectures and get common flags
     SET(_ARCH_NEXT)
@@ -183,6 +208,9 @@ MACRO(PCH_SET_COMPILE_COMMAND _inputcpp _compile_FLAGS)
   IF(MSVC)
     GET_PDB_FILENAME(PDB_FILE ${_PCH_current_target})
     SET(PCH_COMMAND ${CMAKE_CXX_COMPILER} ${pchsupport_compiler_cxx_arg1} ${_compile_FLAGS} /Yc /Fp"${PCH_OUTPUT}" ${_inputcpp} /Fd"${PDB_FILE}" /c /Fo"${PCH_OUTPUT}.obj")
+    # Ninja PCH Support
+    # http://public.kitware.com/pipermail/cmake-developers/2012-March/003653.html
+    SET_SOURCE_FILES_PROPERTIES(${_inputcpp} PROPERTIES OBJECT_OUTPUTS "${PCH_OUTPUT}.obj")
   ELSE(MSVC)
     SET(HEADER_FORMAT "c++-header")
     SET(_FLAGS "")
@@ -242,6 +270,18 @@ MACRO(ADD_PRECOMPILED_HEADER_TO_TARGET _targetName)
 
   IF(MSVC)
     SET(_target_cflags "${oldProps} /Yu\"${PCH_INPUT}\" /FI\"${PCH_INPUT}\" /Fp\"${PCH_OUTPUT}\"")
+    # Ninja PCH Support
+    # http://public.kitware.com/pipermail/cmake-developers/2012-March/003653.html
+    SET_TARGET_PROPERTIES(${_targetName} PROPERTIES OBJECT_DEPENDS "${PCH_OUTPUT}")
+    
+    # NMAKE-VS2012 Error LNK2011 (NMAKE-VS2010 do not complain)
+    # we need to link the pch.obj file, see http://msdn.microsoft.com/en-us/library/3ay26wa2(v=vs.110).aspx
+    GET_TARGET_PROPERTY(DEPS ${_targetName} LINK_LIBRARIES)
+    IF(NOT DEPS)
+      SET(DEPS)
+    ENDIF()
+    LIST(INSERT DEPS 0 "${PCH_OUTPUT}.obj")
+    SET_TARGET_PROPERTIES(${_targetName} PROPERTIES LINK_LIBRARIES "${DEPS}")
   ELSE(MSVC)
     # for use with distcc and gcc >4.0.1 if preprocessed files are accessible
     # on all remote machines set
@@ -329,17 +369,6 @@ MACRO(ADD_PRECOMPILED_HEADER _targetName _inputh _inputcpp)
   SET_DIRECTORY_PROPERTIES(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${PCH_OUTPUTS}")
 ENDMACRO(ADD_PRECOMPILED_HEADER)
 
-# Macro to move PCH creation file to the front of files list
-# or remove .cpp from library/executable to avoid warning
-MACRO(FIX_PRECOMPILED_HEADER _files _pch)
-  # Remove .cpp creating PCH from the list
-  LIST(REMOVE_ITEM ${_files} ${_pch})
-  IF(MSVC)
-    # Prepend .cpp creating PCH to the list
-    LIST(INSERT ${_files} 0 ${_pch})
-  ENDIF(MSVC)
-ENDMACRO(FIX_PRECOMPILED_HEADER)
-
 MACRO(ADD_NATIVE_PRECOMPILED_HEADER _targetName _inputh _inputcpp)
   IF(NOT PCHSupport_FOUND)
     MESSAGE(STATUS "PCH disabled because compiler doesn't support them")
@@ -351,10 +380,6 @@ MACRO(ADD_NATIVE_PRECOMPILED_HEADER _targetName _inputh _inputcpp)
   # 2 => setting PCH for XCode project, works for XCode projects
   IF(CMAKE_GENERATOR MATCHES "Visual Studio")
     SET(PCH_METHOD 1)
-  ELSEIF(CMAKE_GENERATOR MATCHES "NMake Makefiles" AND MFC_FOUND AND CMAKE_MFC_FLAG)
-    # To fix a bug with MFC
-    # Don't forget to use FIX_PRECOMPILED_HEADER before creating the target
-#    SET(PCH_METHOD 1)
   ELSEIF(CMAKE_GENERATOR MATCHES "Xcode")
     SET(PCH_METHOD 2)
   ELSE(CMAKE_GENERATOR MATCHES "Visual Studio")

code/CMakeModules/iOSToolChain.cmake

@@ -0,0 +1,183 @@
+# This file is based off of the Platform/Darwin.cmake and Platform/UnixPaths.cmake
+# files which are included with CMake 2.8.4
+# It has been altered for iOS development
+#
+# Options:
+#
+# IOS_VERSION = last(default) or specific one (4.3, 5.0, 4.1)
+#   This decides if SDKS will be selected from the iPhoneOS.platform or iPhoneSimulator.platform folders
+#   OS - the default, used to build for iPhone and iPad physical devices, which have an arm arch.
+#   SIMULATOR - used to build for the Simulator platforms, which have an x86 arch.
+#
+# IOS_PLATFORM = OS (default) or SIMULATOR or ALL
+#   This decides if SDKS will be selected from the iPhoneOS.platform or iPhoneSimulator.platform folders
+#   OS - the default, used to build for iPhone and iPad physical devices, which have an arm arch.
+#   SIMULATOR - used to build for the Simulator platforms, which have an x86 arch.
+#
+# CMAKE_IOS_DEVELOPER_ROOT = automatic(default) or /path/to/platform/Developer folder
+#   By default this location is automatcially chosen based on the IOS_PLATFORM value above.
+#   If set manually, it will override the default location and force the user of a particular Developer Platform
+#
+# CMAKE_IOS_SDK_ROOT = automatic(default) or /path/to/platform/Developer/SDKs/SDK folder
+#   By default this location is automatcially chosen based on the CMAKE_IOS_DEVELOPER_ROOT value.
+#   In this case it will always be the most up-to-date SDK found in the CMAKE_IOS_DEVELOPER_ROOT path.
+#   If set manually, this will force the use of a specific SDK version
+
+IF(DEFINED CMAKE_CROSSCOMPILING)
+  # subsequent toolchain loading is not really needed
+  RETURN()
+ENDIF()
+
+# Standard settings
+SET(CMAKE_SYSTEM_NAME Darwin)
+SET(CMAKE_SYSTEM_VERSION 1) # TODO: determine target Darwin version
+SET(UNIX ON)
+SET(APPLE ON)
+SET(IOS ON)
+
+# Force the compilers to Clang for iOS
+include (CMakeForceCompiler)
+CMAKE_FORCE_C_COMPILER (clang Clang)
+CMAKE_FORCE_CXX_COMPILER (clang++ Clang)
+
+# Setup iOS platform
+if (NOT DEFINED IOS_PLATFORM)
+  set (IOS_PLATFORM "OS")
+endif (NOT DEFINED IOS_PLATFORM)
+set (IOS_PLATFORM ${IOS_PLATFORM} CACHE STRING "Type of iOS Platform")
+
+SET(IOS_PLATFORM_LOCATION "iPhoneOS.platform")
+SET(IOS_SIMULATOR_PLATFORM_LOCATION "iPhoneSimulator.platform")
+
+# Check the platform selection and setup for developer root
+if (${IOS_PLATFORM} STREQUAL "OS")
+  # This causes the installers to properly locate the output libraries
+  set (CMAKE_XCODE_EFFECTIVE_PLATFORMS "-iphoneos")
+elseif (${IOS_PLATFORM} STREQUAL "SIMULATOR")
+  # This causes the installers to properly locate the output libraries
+  set (CMAKE_XCODE_EFFECTIVE_PLATFORMS "-iphonesimulator")
+elseif (${IOS_PLATFORM} STREQUAL "ALL")
+  # This causes the installers to properly locate the output libraries
+  set (CMAKE_XCODE_EFFECTIVE_PLATFORMS "-iphonesimulator;-iphoneos")
+else (${IOS_PLATFORM} STREQUAL "OS")
+  message (FATAL_ERROR "Unsupported IOS_PLATFORM value selected. Please choose OS or SIMULATOR")
+endif (${IOS_PLATFORM} STREQUAL "OS")
+set (CMAKE_XCODE_EFFECTIVE_PLATFORMS ${CMAKE_XCODE_EFFECTIVE_PLATFORMS} CACHE PATH "iOS Platform")
+
+# Setup iOS developer location unless specified manually with CMAKE_IOS_DEVELOPER_ROOT
+# Note Xcode 4.3 changed the installation location, choose the most recent one available
+SET(XCODE_POST_43_ROOT "/Applications/Xcode.app/Contents/Developer/Platforms")
+SET(XCODE_PRE_43_ROOT "/Developer/Platforms")
+
+IF(NOT DEFINED CMAKE_IOS_DEVELOPER_ROOT)
+  IF(EXISTS ${XCODE_POST_43_ROOT})
+    SET(CMAKE_XCODE_ROOT ${XCODE_POST_43_ROOT})
+  ELSEIF(EXISTS ${XCODE_PRE_43_ROOT})
+    SET(CMAKE_XCODE_ROOT ${XCODE_PRE_43_ROOT})
+  ENDIF(EXISTS ${XCODE_POST_43_ROOT})
+  IF(EXISTS ${CMAKE_XCODE_ROOT}/${IOS_PLATFORM_LOCATION}/Developer)
+    SET(CMAKE_IOS_DEVELOPER_ROOT ${CMAKE_XCODE_ROOT}/${IOS_PLATFORM_LOCATION}/Developer)
+  ENDIF(EXISTS ${CMAKE_XCODE_ROOT}/${IOS_PLATFORM_LOCATION}/Developer)
+  IF(EXISTS ${CMAKE_XCODE_ROOT}/${IOS_SIMULATOR_PLATFORM_LOCATION}/Developer)
+    SET(CMAKE_IOS_SIMULATOR_DEVELOPER_ROOT ${CMAKE_XCODE_ROOT}/${IOS_SIMULATOR_PLATFORM_LOCATION}/Developer)
+  ENDIF(EXISTS ${CMAKE_XCODE_ROOT}/${IOS_SIMULATOR_PLATFORM_LOCATION}/Developer)
+ENDIF(NOT DEFINED CMAKE_IOS_DEVELOPER_ROOT)
+SET(CMAKE_IOS_DEVELOPER_ROOT ${CMAKE_IOS_DEVELOPER_ROOT} CACHE PATH "Location of iOS Platform")
+SET(CMAKE_IOS_SIMULATOR_DEVELOPER_ROOT ${CMAKE_IOS_SIMULATOR_DEVELOPER_ROOT} CACHE PATH "Location of iOS Simulator Platform")
+
+MACRO(GET_AVAILABLE_SDK_VERSIONS ROOT VERSIONS)
+  FILE(GLOB _CMAKE_IOS_SDKS "${ROOT}/SDKs/iPhoneOS*")
+  IF(_CMAKE_IOS_SDKS)
+    LIST(SORT _CMAKE_IOS_SDKS)
+    LIST(REVERSE _CMAKE_IOS_SDKS)
+    FOREACH(_CMAKE_IOS_SDK ${_CMAKE_IOS_SDKS})
+      STRING(REGEX REPLACE ".+iPhoneOS([0-9.]+)\\.sdk" "\\1" _IOS_SDK "${_CMAKE_IOS_SDK}")
+      LIST(APPEND ${VERSIONS} ${_IOS_SDK})
+    ENDFOREACH(_CMAKE_IOS_SDK)
+  ENDIF(_CMAKE_IOS_SDKS)
+ENDMACRO(GET_AVAILABLE_SDK_VERSIONS)
+
+# Find and use the most recent iOS sdk 
+IF(NOT DEFINED CMAKE_IOS_SDK_ROOT)
+  # Search for a specific version of a SDK
+  GET_AVAILABLE_SDK_VERSIONS(${CMAKE_IOS_DEVELOPER_ROOT} IOS_VERSIONS)
+
+  IF(NOT IOS_VERSIONS)
+    MESSAGE(FATAL_ERROR "No iOS SDK's found in default search path ${CMAKE_IOS_DEVELOPER_ROOT}. Manually set CMAKE_IOS_SDK_ROOT or install the iOS SDK.")
+  ENDIF(NOT IOS_VERSIONS)
+  
+  IF(IOS_VERSION)
+    LIST(FIND IOS_VERSIONS "${IOS_VERSION}" _INDEX)
+    IF(_INDEX EQUAL -1)
+      LIST(GET IOS_VERSIONS 0 IOS_SDK_VERSION)
+    ELSE(_INDEX EQUAL -1)
+      SET(IOS_SDK_VERSION ${IOS_VERSION})
+    ENDIF(_INDEX EQUAL -1)
+  ELSE(IOS_VERSION)
+    LIST(GET IOS_VERSIONS 0 IOS_VERSION)
+    SET(IOS_SDK_VERSION ${IOS_VERSION})
+  ENDIF(IOS_VERSION)
+
+  MESSAGE(STATUS "Target iOS ${IOS_VERSION} and use SDK ${IOS_SDK_VERSION}")
+
+  SET(CMAKE_IOS_SDK_ROOT ${CMAKE_IOS_DEVELOPER_ROOT}/SDKs/iPhoneOS${IOS_SDK_VERSION}.sdk)
+  SET(CMAKE_IOS_SIMULATOR_SDK_ROOT ${CMAKE_IOS_SIMULATOR_DEVELOPER_ROOT}/SDKs/iPhoneSimulator${IOS_SDK_VERSION}.sdk)
+endif (NOT DEFINED CMAKE_IOS_SDK_ROOT)
+
+SET(CMAKE_IOS_SDK_ROOT ${CMAKE_IOS_SDK_ROOT} CACHE PATH "Location of the selected iOS SDK")
+SET(CMAKE_IOS_SIMULATOR_SDK_ROOT ${CMAKE_IOS_SIMULATOR_SDK_ROOT} CACHE PATH "Location of the selected iOS Simulator SDK")
+
+SET(IOS_VERSION ${IOS_VERSION} CACHE STRING "iOS target version")
+
+# Set the sysroot default to the most recent SDK
+SET(CMAKE_IOS_SYSROOT ${CMAKE_IOS_SDK_ROOT} CACHE PATH "Sysroot used for iOS support")
+SET(CMAKE_IOS_SIMULATOR_SYSROOT ${CMAKE_IOS_SIMULATOR_SDK_ROOT} CACHE PATH "Sysroot used for iOS Simulator support")
+
+IF(CMAKE_GENERATOR MATCHES Xcode)
+  SET(ARCHS "$(ARCHS_STANDARD_32_BIT)")
+  IF(${IOS_PLATFORM} STREQUAL "OS")
+    SET(CMAKE_SYSTEM_PROCESSOR "armv7")
+  ELSEIF(${IOS_PLATFORM} STREQUAL "SIMULATOR")
+    SET(CMAKE_SYSTEM_PROCESSOR "x86")
+  ELSEIF(${IOS_PLATFORM} STREQUAL "ALL")
+    SET(CMAKE_SYSTEM_PROCESSOR "armv7")
+  ENDIF(${IOS_PLATFORM} STREQUAL "OS")
+ELSE(CMAKE_GENERATOR MATCHES Xcode)
+  IF(${IOS_PLATFORM} STREQUAL "OS")
+    SET(ARCHS "armv7")
+    SET(CMAKE_SYSTEM_PROCESSOR "armv7")
+  ELSEIF(${IOS_PLATFORM} STREQUAL "SIMULATOR")
+    # iPhone simulator targets i386
+    SET(ARCHS "i386")
+    SET(CMAKE_SYSTEM_PROCESSOR "x86")
+  ELSEIF(${IOS_PLATFORM} STREQUAL "ALL")
+    SET(ARCHS "armv7;i386")
+    SET(CMAKE_SYSTEM_PROCESSOR "armv7")
+  ENDIF(${IOS_PLATFORM} STREQUAL "OS")
+ENDIF(CMAKE_GENERATOR MATCHES Xcode)
+
+# set the architecture for iOS - using ARCHS_STANDARD_32_BIT sets armv7,armv7s and appears to be XCode's standard. 
+# The other value that works is ARCHS_UNIVERSAL_IPHONE_OS but that sets armv7 only
+set (CMAKE_OSX_ARCHITECTURES ${ARCHS} CACHE string  "Build architecture for iOS")
+
+# Set the find root to the iOS developer roots and to user defined paths
+set (CMAKE_FIND_ROOT_PATH ${CMAKE_IOS_DEVELOPER_ROOT} ${CMAKE_IOS_SDK_ROOT} ${CMAKE_PREFIX_PATH} ${CMAKE_INSTALL_PREFIX} $ENV{EXTERNAL_IOS_PATH} CACHE string  "iOS find search path root")
+
+# default to searching for frameworks first
+set (CMAKE_FIND_FRAMEWORK FIRST)
+
+# set up the default search directories for frameworks
+set (CMAKE_SYSTEM_FRAMEWORK_PATH
+  ${CMAKE_IOS_SDK_ROOT}/System/Library/Frameworks
+  ${CMAKE_IOS_SDK_ROOT}/System/Library/PrivateFrameworks
+  ${CMAKE_IOS_SDK_ROOT}/Developer/Library/Frameworks
+)
+
+# only search the iOS sdks, not the remainder of the host filesystem
+set (CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set (CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set (CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+
+#SET(CMAKE_SYSTEM_INCLUDE_PATH /include /usr/include)
+#SET(CMAKE_SYSTEM_LIBRARY_PATH /lib /usr/lib)
+#SET(CMAKE_SYSTEM_PROGRAM_PATH /bin /usr/bin)

code/CMakeModules/nel.cmake

@@ -125,10 +125,6 @@ MACRO(NL_DEFAULT_PROPS name label)
       COMPILE_FLAGS "/GA"
       LINK_FLAGS "/VERSION:${NL_VERSION_MAJOR}.${NL_VERSION_MINOR}")
   ENDIF(${type} STREQUAL EXECUTABLE AND WIN32)
-
-  IF(WITH_STLPORT AND WIN32)
-    SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "/X")
-  ENDIF(WITH_STLPORT AND WIN32)
 ENDMACRO(NL_DEFAULT_PROPS)
 
 ###
@@ -324,6 +320,9 @@ MACRO(NL_SETUP_NEL_DEFAULT_OPTIONS)
   OPTION(WITH_NEL_MAXPLUGIN       "Build NeL 3dsMax Plugin"                       OFF)
   OPTION(WITH_NEL_SAMPLES         "Build NeL Samples"                             ON )
   OPTION(WITH_NEL_TESTS           "Build NeL Unit Tests"                          ON )
+
+  OPTION(WITH_LIBOVR              "With LibOVR support"                           OFF)
+  OPTION(WITH_LIBVR               "With LibVR support"                            OFF)
 ENDMACRO(NL_SETUP_NEL_DEFAULT_OPTIONS)
 
 MACRO(NL_SETUP_NELNS_DEFAULT_OPTIONS)
@@ -346,7 +345,8 @@ MACRO(NL_SETUP_RYZOM_DEFAULT_OPTIONS)
   ###
   # Optional support
   ###
-  OPTION(WITH_LUA51               "Build Ryzom Core using Lua51"                  ON )
+  OPTION(WITH_LUA51               "Build Ryzom Core using Lua 5.1"                ON )
+  OPTION(WITH_LUA52               "Build Ryzom Core using Lua 5.2"                OFF)
 ENDMACRO(NL_SETUP_RYZOM_DEFAULT_OPTIONS)
 
 MACRO(NL_SETUP_SNOWBALLS_DEFAULT_OPTIONS)
@@ -387,11 +387,11 @@ MACRO(NL_SETUP_BUILD)
 
   SET(HOST_CPU ${CMAKE_HOST_SYSTEM_PROCESSOR})
 
-  IF(HOST_CPU MATCHES "amd64")
+  IF(HOST_CPU MATCHES "(amd|AMD)64")
     SET(HOST_CPU "x86_64")
   ELSEIF(HOST_CPU MATCHES "i.86")
     SET(HOST_CPU "x86")
-  ENDIF(HOST_CPU MATCHES "amd64")
+  ENDIF(HOST_CPU MATCHES "(amd|AMD)64")
   
   # Determine target CPU
 
@@ -400,11 +400,11 @@ MACRO(NL_SETUP_BUILD)
     SET(TARGET_CPU ${CMAKE_SYSTEM_PROCESSOR})
   ENDIF(NOT TARGET_CPU)
 
-  IF(TARGET_CPU MATCHES "amd64")
+  IF(TARGET_CPU MATCHES "(amd|AMD)64")
     SET(TARGET_CPU "x86_64")
   ELSEIF(TARGET_CPU MATCHES "i.86")
     SET(TARGET_CPU "x86")
-  ENDIF(TARGET_CPU MATCHES "amd64")
+  ENDIF(TARGET_CPU MATCHES "(amd|AMD)64")
 
   IF(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
     SET(CLANG ON)
@@ -416,6 +416,11 @@ MACRO(NL_SETUP_BUILD)
     MESSAGE(STATUS "Generating Xcode project")
   ENDIF(CMAKE_GENERATOR MATCHES "Xcode")
 
+  IF(CMAKE_GENERATOR MATCHES "NMake")
+    SET(NMAKE ON)
+    MESSAGE(STATUS "Generating NMake project")
+  ENDIF(CMAKE_GENERATOR MATCHES "NMake")
+
   # If target and host CPU are the same
   IF("${HOST_CPU}" STREQUAL "${TARGET_CPU}" AND NOT CMAKE_CROSSCOMPILING)
     # x86-compatible CPU
@@ -535,6 +540,9 @@ MACRO(NL_SETUP_BUILD)
       SET(MSVC11 ON)
     ENDIF(MSVC_VERSION EQUAL "1700" AND NOT MSVC11)
 
+    # Ignore default include paths
+    ADD_PLATFORM_FLAGS("/X")
+
     IF(MSVC11)
       ADD_PLATFORM_FLAGS("/Gy- /MP")
       # /Ox is working with VC++ 2010, but custom optimizations don't exist
@@ -894,20 +902,23 @@ ENDMACRO(NL_SETUP_BUILD)
 MACRO(NL_SETUP_BUILD_FLAGS)
   SET(CMAKE_C_FLAGS ${PLATFORM_CFLAGS} CACHE STRING "" FORCE)
   SET(CMAKE_CXX_FLAGS ${PLATFORM_CXXFLAGS} CACHE STRING "" FORCE)
+  SET(CMAKE_EXE_LINKER_FLAGS ${PLATFORM_LINKFLAGS} CACHE STRING "" FORCE)
+  SET(CMAKE_MODULE_LINKER_FLAGS ${PLATFORM_LINKFLAGS} CACHE STRING "" FORCE)
+  SET(CMAKE_SHARED_LINKER_FLAGS ${PLATFORM_LINKFLAGS} CACHE STRING "" FORCE)
 
   ## Debug
   SET(CMAKE_C_FLAGS_DEBUG ${NL_DEBUG_CFLAGS} CACHE STRING "" FORCE)
   SET(CMAKE_CXX_FLAGS_DEBUG ${NL_DEBUG_CFLAGS} CACHE STRING "" FORCE)
-  SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "${PLATFORM_LINKFLAGS} ${NL_DEBUG_LINKFLAGS}" CACHE STRING "" FORCE)
+  SET(CMAKE_EXE_LINKER_FLAGS_DEBUG ${NL_DEBUG_LINKFLAGS} CACHE STRING "" FORCE)
-  SET(CMAKE_MODULE_LINKER_FLAGS_DEBUG "${PLATFORM_LINKFLAGS} ${NL_DEBUG_LINKFLAGS}" CACHE STRING "" FORCE)
+  SET(CMAKE_MODULE_LINKER_FLAGS_DEBUG ${NL_DEBUG_LINKFLAGS} CACHE STRING "" FORCE)
-  SET(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${PLATFORM_LINKFLAGS} ${NL_DEBUG_LINKFLAGS}" CACHE STRING "" FORCE)
+  SET(CMAKE_SHARED_LINKER_FLAGS_DEBUG ${NL_DEBUG_LINKFLAGS} CACHE STRING "" FORCE)
 
   ## Release
   SET(CMAKE_C_FLAGS_RELEASE ${NL_RELEASE_CFLAGS} CACHE STRING "" FORCE)
   SET(CMAKE_CXX_FLAGS_RELEASE ${NL_RELEASE_CFLAGS} CACHE STRING "" FORCE)
-  SET(CMAKE_EXE_LINKER_FLAGS_RELEASE "${PLATFORM_LINKFLAGS} ${NL_RELEASE_LINKFLAGS}" CACHE STRING "" FORCE)
+  SET(CMAKE_EXE_LINKER_FLAGS_RELEASE ${NL_RELEASE_LINKFLAGS} CACHE STRING "" FORCE)
-  SET(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${PLATFORM_LINKFLAGS} ${NL_RELEASE_LINKFLAGS}" CACHE STRING "" FORCE)
+  SET(CMAKE_MODULE_LINKER_FLAGS_RELEASE ${NL_RELEASE_LINKFLAGS} CACHE STRING "" FORCE)
-  SET(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${PLATFORM_LINKFLAGS} ${NL_RELEASE_LINKFLAGS}" CACHE STRING "" FORCE)
+  SET(CMAKE_SHARED_LINKER_FLAGS_RELEASE ${NL_RELEASE_LINKFLAGS} CACHE STRING "" FORCE)
 ENDMACRO(NL_SETUP_BUILD_FLAGS)
 
 # Macro to create x_ABSOLUTE_PREFIX from x_PREFIX
@@ -1061,74 +1072,14 @@ MACRO(SETUP_EXTERNAL)
   IF(WIN32)
     FIND_PACKAGE(External REQUIRED)
 
-    IF(NOT VC_DIR)
+    # If using custom boost, we need to define the right variables used by official boost CMake module
-      SET(VC_DIR $ENV{VC_DIR})
+    IF(DEFINED BOOST_DIR)
-    ENDIF(NOT VC_DIR)
+      SET(BOOST_INCLUDEDIR ${BOOST_DIR}/include)
-
+      SET(BOOST_LIBRARYDIR ${BOOST_DIR}/lib)
-    IF(MSVC11)
+    ENDIF(DEFINED BOOST_DIR)
-      IF(NOT MSVC_REDIST_DIR)
-        # If you have VC++ 2012 Express, put x64/Microsoft.VC110.CRT/*.dll in ${EXTERNAL_PATH}/redist
-        SET(MSVC_REDIST_DIR "${EXTERNAL_PATH}/redist")
-      ENDIF(NOT MSVC_REDIST_DIR)
-
-      IF(NOT VC_DIR)
-        IF(NOT VC_ROOT_DIR)
-          GET_FILENAME_COMPONENT(VC_ROOT_DIR "[HKEY_CURRENT_USER\\Software\\Microsoft\\VisualStudio\\11.0_Config;InstallDir]" ABSOLUTE)
-          # VC_ROOT_DIR is set to "registry" when a key is not found
-          IF(VC_ROOT_DIR MATCHES "registry")
-            GET_FILENAME_COMPONENT(VC_ROOT_DIR "[HKEY_CURRENT_USER\\Software\\Microsoft\\WDExpress\\11.0_Config\\Setup\\VC;InstallDir]" ABSOLUTE)
-            IF(VC_ROOT_DIR MATCHES "registry")
-              SET(VS110COMNTOOLS $ENV{VS110COMNTOOLS})
-              IF(VS110COMNTOOLS)
-                FILE(TO_CMAKE_PATH ${VS110COMNTOOLS} VC_ROOT_DIR)
-              ENDIF(VS110COMNTOOLS)
-              IF(NOT VC_ROOT_DIR)
-                MESSAGE(FATAL_ERROR "Unable to find VC++ 2012 directory!")
-              ENDIF(NOT VC_ROOT_DIR)
-            ENDIF(VC_ROOT_DIR MATCHES "registry")
-          ENDIF(VC_ROOT_DIR MATCHES "registry")
-        ENDIF(NOT VC_ROOT_DIR)
-        # convert IDE fullpath to VC++ path
-        STRING(REGEX REPLACE "Common7/.*" "VC" VC_DIR ${VC_ROOT_DIR})
-      ENDIF(NOT VC_DIR)
-    ELSEIF(MSVC10)
-      IF(NOT MSVC_REDIST_DIR)
-        # If you have VC++ 2010 Express, put x64/Microsoft.VC100.CRT/*.dll in ${EXTERNAL_PATH}/redist
-        SET(MSVC_REDIST_DIR "${EXTERNAL_PATH}/redist")
-      ENDIF(NOT MSVC_REDIST_DIR)
-
-      IF(NOT VC_DIR)
-        IF(NOT VC_ROOT_DIR)
-          GET_FILENAME_COMPONENT(VC_ROOT_DIR "[HKEY_CURRENT_USER\\Software\\Microsoft\\VisualStudio\\10.0_Config;InstallDir]" ABSOLUTE)
-          # VC_ROOT_DIR is set to "registry" when a key is not found
-          IF(VC_ROOT_DIR MATCHES "registry")
-            GET_FILENAME_COMPONENT(VC_ROOT_DIR "[HKEY_CURRENT_USER\\Software\\Microsoft\\VCExpress\\10.0_Config;InstallDir]" ABSOLUTE)
-            IF(VC_ROOT_DIR MATCHES "registry")
-              SET(VS100COMNTOOLS $ENV{VS100COMNTOOLS})
-              IF(VS100COMNTOOLS)
-                FILE(TO_CMAKE_PATH ${VS100COMNTOOLS} VC_ROOT_DIR)
-              ENDIF(VS100COMNTOOLS)
-              IF(NOT VC_ROOT_DIR)
-                MESSAGE(FATAL_ERROR "Unable to find VC++ 2010 directory!")
-              ENDIF(NOT VC_ROOT_DIR)
-            ENDIF(VC_ROOT_DIR MATCHES "registry")
-          ENDIF(VC_ROOT_DIR MATCHES "registry")
-        ENDIF(NOT VC_ROOT_DIR)
-        # convert IDE fullpath to VC++ path
-        STRING(REGEX REPLACE "Common7/.*" "VC" VC_DIR ${VC_ROOT_DIR})
-      ENDIF(NOT VC_DIR)
-    ELSE(MSVC11)
-      IF(NOT VC_DIR)
-        IF(${CMAKE_MAKE_PROGRAM} MATCHES "Common7")
-          # convert IDE fullpath to VC++ path
-          STRING(REGEX REPLACE "Common7/.*" "VC" VC_DIR ${CMAKE_MAKE_PROGRAM})
-        ELSE(${CMAKE_MAKE_PROGRAM} MATCHES "Common7")
-          # convert compiler fullpath to VC++ path
-          STRING(REGEX REPLACE "VC/bin/.+" "VC" VC_DIR ${CMAKE_CXX_COMPILER})
-        ENDIF(${CMAKE_MAKE_PROGRAM} MATCHES "Common7")
-      ENDIF(NOT VC_DIR)
-    ENDIF(MSVC11)
   ELSE(WIN32)
+    FIND_PACKAGE(External QUIET)
+
     IF(APPLE)
       IF(WITH_STATIC_EXTERNAL)
         SET(CMAKE_FIND_LIBRARY_SUFFIXES .a)
@@ -1144,15 +1095,22 @@ MACRO(SETUP_EXTERNAL)
     ENDIF(APPLE)
   ENDIF(WIN32)
 
+  # Android and iOS have pthread  
+  IF(ANDROID OR IOS)
+    SET(CMAKE_USE_PTHREADS_INIT 1)
+    SET(Threads_FOUND TRUE)
+  ELSE(ANDROID OR IOS)
+    FIND_PACKAGE(Threads REQUIRED)
+    # TODO: replace all -l<lib> by absolute path to <lib> in CMAKE_THREAD_LIBS_INIT
+  ENDIF(ANDROID OR IOS)
+
   IF(WITH_STLPORT)
     FIND_PACKAGE(STLport REQUIRED)
     INCLUDE_DIRECTORIES(${STLPORT_INCLUDE_DIR})
-    IF(MSVC)
-      SET(VC_INCLUDE_DIR "${VC_DIR}/include")
-
-      FIND_PACKAGE(WindowsSDK REQUIRED)
-      # use VC++ and Windows SDK include paths
-      INCLUDE_DIRECTORIES(${VC_INCLUDE_DIR} ${WINSDK_INCLUDE_DIRS})
-    ENDIF(MSVC)
   ENDIF(WITH_STLPORT)
+
+  IF(MSVC)
+    FIND_PACKAGE(MSVC REQUIRED)
+    FIND_PACKAGE(WindowsSDK REQUIRED)
+  ENDIF(MSVC)
 ENDMACRO(SETUP_EXTERNAL)

code/nel/CMakeLists.txt

@@ -41,6 +41,14 @@ IF(WITH_GTK)
   FIND_PACKAGE(GTK2)
 ENDIF(WITH_GTK)
 
+IF(WITH_LIBOVR)
+  FIND_PACKAGE(LibOVR)
+ENDIF(WITH_LIBOVR)
+
+IF(WITH_LIBVR)
+  FIND_PACKAGE(LibVR)
+ENDIF(WITH_LIBVR)
+
 IF(WITH_INSTALL_LIBRARIES)
   IF(UNIX)
     SET(prefix ${CMAKE_INSTALL_PREFIX})

code/nel/include/nel/3d/bloom_effect.h

@@ -138,6 +138,8 @@ private:
 	NLMISC::CSmartPtr<NL3D::ITexture>  _BlurFinalTex;
 	// used as render target in first blur pass, and as displayed texture on second blur pass.
 	NLMISC::CSmartPtr<NL3D::ITexture>  _BlurHorizontalTex;
+	// original render target
+	NLMISC::CSmartPtr<NL3D::ITexture>  _OriginalRenderTarget;
 
 
 	// materials

code/nel/include/nel/3d/driver_user.h

@@ -133,6 +133,7 @@ public:
 	// @{
 
 	virtual void			disableHardwareVertexProgram();
+	virtual void			disableHardwarePixelProgram();
 	virtual void			disableHardwareVertexArrayAGP();
 	virtual void			disableHardwareTextureShader();
 
@@ -473,7 +474,6 @@ public:
 	virtual void			forceDXTCCompression(bool dxtcComp);
 	virtual void			setAnisotropicFilter(sint filter);
 	virtual void			forceTextureResize(uint divisor);
-	virtual void			forceNativeFragmentPrograms(bool nativeOnly);
 	virtual bool			setMonitorColorProperties (const CMonitorColorProperties &properties);
 	// @}
 

code/nel/include/nel/3d/geometry_program.h

@@ -0,0 +1,49 @@
+/** \file geometry_program.h
+ * Geometry program definition
+ */
+
+/* Copyright, 2000, 2001 Nevrax Ltd.
+ *
+ * This file is part of NEVRAX NEL.
+ * NEVRAX NEL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+
+ * NEVRAX NEL is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with NEVRAX NEL; see the file COPYING. If not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ */
+
+#ifndef NL_GEOMETRY_PROGRAM_H
+#define NL_GEOMETRY_PROGRAM_H
+
+#include <nel/misc/types_nl.h>
+#include <nel/misc/smart_ptr.h>
+#include <nel/3d/program.h>
+
+#include <list>
+
+namespace NL3D {
+
+class CGeometryProgram : public IProgram
+{
+public:
+	/// Constructor
+	CGeometryProgram();
+	/// Destructor
+	virtual ~CGeometryProgram ();
+};
+
+} // NL3D
+
+
+#endif // NL_GEOMETRY_PROGRAM_H
+
+/* End of vertex_program.h */

code/nel/include/nel/3d/gpu_program_params.h

@@ -0,0 +1,178 @@
+/**
+ * \file gpu_program_params.h
+ * \brief CGPUProgramParams
+ * \date 2013-09-07 22:17GMT
+ * \author Jan Boon (Kaetemi)
+ * CGPUProgramParams
+ */
+
+/* 
+ * Copyright (C) 2013  by authors
+ * 
+ * This file is part of NL3D.
+ * NL3D is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * NL3D is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
+ * Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public
+ * License along with NL3D.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef NL3D_GPU_PROGRAM_PARAMS_H
+#define NL3D_GPU_PROGRAM_PARAMS_H
+#include <nel/misc/types_nl.h>
+
+// STL includes
+#include <map>
+#include <vector>
+
+// NeL includes
+
+// Project includes
+
+namespace NLMISC {
+	class CVector;
+	class CMatrix;
+}
+
+namespace NL3D {
+
+/**
+ * \brief CGPUProgramParams
+ * \date 2013-09-07 22:17GMT
+ * \author Jan Boon (Kaetemi)
+ * A storage for USERCODE-PROVIDED parameters for GPU programs.
+ * Allows for fast updating and iteration of parameters.
+ * NOTE TO DRIVER IMPLEMENTORS: DO NOT USE FOR STORING COPIES 
+ * OF HARDCODED DRIVER MATERIAL PARAMETERS OR DRIVER PARAMETERS!!!
+ * The 4-component alignment that is done in this storage
+ * class is necessary to simplify support for register-based
+ * assembly shaders, which require setting per 4 components.
+ */
+class CGPUProgramParams
+{
+public:
+	enum TType { Float, Int, UInt };
+	struct CMeta { uint Index, Size, Count; TType Type; std::string Name; size_t Next, Prev; }; // size is element size, count is nb of elements
+
+private:
+	union CVec { float F[4]; sint32 I[4]; uint32 UI[4]; };
+
+public:
+	CGPUProgramParams();
+	virtual ~CGPUProgramParams();
+
+	/// \name User functions
+	// @{
+	// Copy from another params storage
+	void copy(CGPUProgramParams *params);
+
+	// Set by index, available only when the associated program has been compiled
+	void set1f(uint index, float f0);
+	void set2f(uint index, float f0, float f1);
+	void set3f(uint index, float f0, float f1, float f2);
+	void set4f(uint index, float f0, float f1, float f2, float f3);
+	void set1i(uint index, sint32 i0);
+	void set2i(uint index, sint32 i0, sint32 i1);
+	void set3i(uint index, sint32 i0, sint32 i1, sint32 i2);
+	void set4i(uint index, sint32 i0, sint32 i1, sint32 i2, sint32 i3);
+	void set1ui(uint index, uint32 ui0);
+	void set2ui(uint index, uint32 ui0, uint32 ui1);
+	void set3ui(uint index, uint32 ui0, uint32 ui1, uint32 ui2);
+	void set4ui(uint index, uint32 ui0, uint32 ui1, uint32 ui2, uint32 ui3);
+	void set3f(uint index, const NLMISC::CVector& v);
+	void set4f(uint index, const NLMISC::CVector& v, float f3);
+	void set4x4f(uint index, const NLMISC::CMatrix& m);
+	void set4fv(uint index, size_t num, const float *src);
+	void set4iv(uint index, size_t num, const sint32 *src);
+	void set4uiv(uint index, size_t num, const uint32 *src);
+	void unset(uint index);
+
+	// Set by name, it is recommended to use index when repeatedly setting an element
+	void set1f(const std::string &name, float f0);
+	void set2f(const std::string &name, float f0, float f1);
+	void set3f(const std::string &name, float f0, float f1, float f2);
+	void set4f(const std::string &name, float f0, float f1, float f2, float f3);
+	void set1i(const std::string &name, sint32 i0);
+	void set2i(const std::string &name, sint32 i0, sint32 i1);
+	void set3i(const std::string &name, sint32 i0, sint32 i1, sint32 i2);
+	void set4i(const std::string &name, sint32 i0, sint32 i1, sint32 i2, sint32 i3);
+	void set1ui(const std::string &name, uint32 ui0);
+	void set2ui(const std::string &name, uint32 ui0, uint32 ui1);
+	void set3ui(const std::string &name, uint32 ui0, uint32 ui1, uint32 ui2);
+	void set4ui(const std::string &name, uint32 ui0, uint32 ui1, uint32 ui2, uint32 ui3);
+	void set3f(const std::string &name, const NLMISC::CVector& v);
+	void set4f(const std::string &name, const NLMISC::CVector& v, float f3);
+	void set4x4f(const std::string &name, const NLMISC::CMatrix& m);
+	void set4fv(const std::string &name, size_t num, const float *src);
+	void set4iv(const std::string &name, size_t num, const sint32 *src);
+	void set4uiv(const std::string &name, size_t num, const uint32 *src);
+	void unset(const std::string &name);
+	// @}
+
+	// Maps the given name to the given index.
+	// on duplicate entry the data set by name will be prefered, as it can be 
+	// assumed to have been set after the data set by index, and the mapping 
+	// will usually happen while iterating and finding an element with name
+	// but no known index.
+	// Unknown index will be set to ~0, unknown name will have an empty string.
+	void map(uint index, const std::string &name);
+
+	/// \name Internal
+	// @{
+	/// Allocate specified number of components if necessary (internal use only)
+	size_t allocOffset(uint index, uint size, uint count, TType type);
+	size_t allocOffset(const std::string &name, uint size, uint count, TType type);
+	size_t allocOffset(uint size, uint count, TType type);
+	/// Return offset for specified index
+	size_t getOffset(uint index) const;
+	size_t getOffset(const std::string &name) const;
+	/// Remove by offset
+	void freeOffset(size_t offset);
+	// @}
+
+	/// \name Driver and dev tools
+	// @{
+	// Iteration (returns the offsets for access using getFooByOffset)
+	inline size_t getBegin() const { return m_Meta.size() ? m_First : s_End; }
+	inline size_t getNext(size_t offset) const { return m_Meta[offset].Next; }
+	inline size_t getEnd() const { return s_End; }
+
+	// Data access
+	inline uint getSizeByOffset(size_t offset) const { return m_Meta[offset].Size; } // size of element (4 for float4)
+	inline uint getCountByOffset(size_t offset) const { return m_Meta[offset].Count; } // number of elements (usually 1)
+	inline uint getNbComponentsByOffset(size_t offset) const { return m_Meta[offset].Size * m_Meta[offset].Count; } // nb of components (size * count)
+	inline float *getPtrFByOffset(size_t offset) { return m_Vec[offset].F; }
+	inline sint32 *getPtrIByOffset(size_t offset) { return m_Vec[offset].I; }
+	inline uint32 *getPtrUIByOffset(size_t offset) { return m_Vec[offset].UI; }
+	inline TType getTypeByOffset(size_t offset) const { return m_Meta[offset].Type; }
+	inline uint getIndexByOffset(size_t offset) const { return m_Meta[offset].Index; }
+	const std::string &getNameByOffset(size_t offset) const { return m_Meta[offset].Name; };
+	// @}
+
+	// Utility
+	static inline uint getNbRegistersByComponents(uint nbComponents) { return (nbComponents + 3) >> 2; } // vector register per 4 components
+
+private:
+	std::vector<CVec> m_Vec;
+	std::vector<CMeta> m_Meta;
+	std::vector<size_t> m_Map; // map from index to offset
+	std::map<std::string, size_t> m_MapName; // map from name to offset
+	size_t m_First;
+	size_t m_Last;
+	static const size_t s_End = -1;
+
+}; /* class CGPUProgramParams */
+
+} /* namespace NL3D */
+
+#endif /* #ifndef NL3D_GPU_PROGRAM_PARAMS_H */
+
+/* end of file */

code/nel/include/nel/3d/landscapevb_allocator.h

@@ -21,6 +21,7 @@
 #include "nel/misc/smart_ptr.h"
 #include "nel/3d/tessellation.h"
 #include "nel/3d/vertex_buffer.h"
+#include "nel/3d/vertex_program.h"
 
 
 namespace NL3D
@@ -41,6 +42,7 @@ class	CVertexProgram;
 #define	NL3D_LANDSCAPE_VPPOS_DELTAPOS		(CVertexBuffer::TexCoord3)
 #define	NL3D_LANDSCAPE_VPPOS_ALPHAINFO		(CVertexBuffer::TexCoord4)
 
+class CVertexProgramLandscape;
 
 // ***************************************************************************
 /**
@@ -107,6 +109,8 @@ public:
 	 * Give a vertexProgram Id to activate. Always 0, but 1 For tile Lightmap Pass.
 	 */
 	void			activate(uint vpId);
+	void			activateVP(uint vpId);
+	inline CVertexProgramLandscape *getVP(uint vpId) const { return _VertexProgram[vpId]; }
 	// @}
 
 
@@ -151,15 +155,35 @@ private:
 
 	/// \name Vertex Program mgt .
 	// @{
+public:
 	enum	{MaxVertexProgram= 2,};
 	// Vertex Program , NULL if not enabled.
-	CVertexProgram		*_VertexProgram[MaxVertexProgram];
+private:
+	NLMISC::CSmartPtr<CVertexProgramLandscape> _VertexProgram[MaxVertexProgram];
 	void				deleteVertexProgram();
 	void				setupVBFormatAndVertexProgram(bool withVertexProgram);
 	// @}
 
 };
 
+class CVertexProgramLandscape : public CVertexProgram
+{
+public:
+	struct CIdx
+	{
+		uint ProgramConstants0;
+		uint RefineCenter;
+		uint TileDist;
+		uint PZBModelPosition;
+	};
+	CVertexProgramLandscape(CLandscapeVBAllocator::TType type, bool lightMap = false);
+	virtual ~CVertexProgramLandscape() { }
+	virtual void buildInfo();
+public:
+	const CIdx &idx() const { return m_Idx; }
+	CIdx m_Idx;
+};
+
 
 } // NL3D
 

code/nel/include/nel/3d/material.h

@@ -22,7 +22,6 @@
 #include "nel/misc/rgba.h"
 #include "nel/misc/matrix.h"
 #include "nel/3d/texture.h"
-#include "nel/3d/shader.h"
 
 #include <memory>
 
@@ -171,7 +170,8 @@ public:
 	 * - Alpha of texture in stage 0 is blended with alpha of texture in stage 1. Blend done with the alpha color of each
 	 * stage and the whole is multiplied by the alpha in color vertex [AT0*ADiffuseCol+AT1*(1-ADiffuseCol)]*AStage
 	 * - RGB still unchanged
-	 *
+	 * Water :
+	 * - Water
 	 */
 	enum TShader			{ Normal=0,
 							  Bump,
@@ -183,7 +183,8 @@ public:
 							  PerPixelLightingNoSpec,
 							  Cloud,
 							  Water,
-							  shaderCount};
+							  shaderCount,
+							  Program /* internally used when a pixel program is active */ };
 
 	/// \name Texture Env Modes.
 	// @{

code/nel/include/nel/3d/meshvp_per_pixel_light.h

@@ -27,6 +27,7 @@
 
 namespace NL3D {
 
+class CVertexProgramPerPixelLight;
 
 /**
  * This vertex program is used to perform perpixel lighting with meshs. Its outputs are :
@@ -49,6 +50,8 @@ namespace NL3D {
 class CMeshVPPerPixelLight : public IMeshVertexProgram
 {
 public:
+	friend class CVertexProgramPerPixelLight;
+
 	/// true if want Specular Lighting.
 	bool		SpecularLighting;
 public:
@@ -84,7 +87,9 @@ private:
 	bool	_IsPointLight;
 	//
 	enum { NumVp = 8};
-	static	std::auto_ptr<CVertexProgram>	_VertexProgram[NumVp];
+	static	NLMISC::CSmartPtr<CVertexProgramPerPixelLight> _VertexProgram[NumVp];
+
+	NLMISC::CRefPtr<CVertexProgramPerPixelLight> _ActiveVertexProgram;
 };
 
 } // NL3D

code/nel/include/nel/3d/meshvp_wind_tree.h

@@ -24,6 +24,7 @@
 
 namespace NL3D {
 
+class CVertexProgramWindTree;
 
 // ***************************************************************************
 /**
@@ -35,6 +36,7 @@ namespace NL3D {
 class CMeshVPWindTree : public IMeshVertexProgram
 {
 public:
+	friend class CVertexProgramWindTree;
 
 	enum	{HrcDepth= 3};
 
@@ -104,6 +106,7 @@ public:
 	// @}
 
 private:
+	static void	initVertexPrograms();
 	void	setupLighting(CScene *scene, CMeshBaseInstance *mbi, const NLMISC::CMatrix &invertedModelMat);
 private:
 
@@ -112,7 +115,9 @@ private:
 	/** The 16 versions: Specular or not (0 or 2), + normalize normal or not (0 or 1).
 	 *	All multiplied by 4, because support from 0 to 3 pointLights activated. (0.., 4.., 8.., 12..)
 	 */
-	static	std::auto_ptr<CVertexProgram>	_VertexProgram[NumVp];
+	static	NLMISC::CSmartPtr<CVertexProgramWindTree> _VertexProgram[NumVp];
+
+	NLMISC::CRefPtr<CVertexProgramWindTree> _ActiveVertexProgram;
 
 	// WindTree Time for this mesh param setup. Stored in mesh because same for all instances.
 	float		_CurrentTime[HrcDepth];

code/nel/include/nel/3d/pixel_program.h

@@ -0,0 +1,49 @@
+/** \file pixel_program.h
+ * Pixel program definition
+ */
+
+/* Copyright, 2000, 2001 Nevrax Ltd.
+ *
+ * This file is part of NEVRAX NEL.
+ * NEVRAX NEL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+
+ * NEVRAX NEL is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with NEVRAX NEL; see the file COPYING. If not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ */
+
+#ifndef NL_PIXEL_PROGRAM_H
+#define NL_PIXEL_PROGRAM_H
+
+#include <nel/misc/types_nl.h>
+#include <nel/misc/smart_ptr.h>
+#include <nel/3d/program.h>
+
+#include <list>
+
+namespace NL3D {
+
+class CPixelProgram : public IProgram
+{
+public:
+	/// Constructor
+	CPixelProgram();
+	/// Destructor
+	virtual ~CPixelProgram ();
+};
+
+} // NL3D
+
+
+#endif // NL_PIXEL_PROGRAM_H
+
+/* End of vertex_program.h */

code/nel/include/nel/3d/program.h

@@ -0,0 +1,264 @@
+/**
+ * \file program.h
+ * \brief IProgram
+ * \date 2013-09-07 15:00GMT
+ * \author Jan Boon (Kaetemi)
+ * IProgram
+ */
+
+/* 
+ * Copyright (C) 2013  by authors
+ * 
+ * This file is part of NL3D.
+ * NL3D is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * NL3D is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
+ * Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public
+ * License along with NL3D.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef NL3D_PROGRAM_H
+#define NL3D_PROGRAM_H
+#include <nel/misc/types_nl.h>
+
+// STL includes
+
+// NeL includes
+#include <nel/misc/smart_ptr.h>
+
+// Project includes
+
+namespace NL3D {
+
+// List typedef.
+class	IDriver;
+class	IProgramDrvInfos;
+typedef	std::list<IProgramDrvInfos*>	TGPUPrgDrvInfoPtrList;
+typedef	TGPUPrgDrvInfoPtrList::iterator		ItGPUPrgDrvInfoPtrList;
+
+// Class for interaction of vertex program with Driver.
+// IProgramDrvInfos represent the real data of the GPU program, stored into the driver (eg: just a GLint for opengl).
+class IProgramDrvInfos : public NLMISC::CRefCount
+{
+private:
+	IDriver					*_Driver;
+	ItGPUPrgDrvInfoPtrList	_DriverIterator;
+
+public:
+	IProgramDrvInfos (IDriver *drv, ItGPUPrgDrvInfoPtrList it);
+	// The virtual dtor is important.
+	virtual ~IProgramDrvInfos(void);
+
+	virtual uint getUniformIndex(const char *name) const = 0;
+};
+
+// Features exposed by a program. Used to set builtin parameters on user provided shaders.
+// This is only used for user provided shaders, not for builtin shaders, 
+// as it is a slow method which has to go through all of the options every time.
+// Builtin shaders should set all flags to 0.
+// Example:
+//   User shader flags Matrices in the Vertex Program:
+//   -> When rendering with a material, the driver will call setUniformDriver,
+//      which will check if the flag Matrices exists, and if so, it will use
+//      the index cache to find which matrices are needed by the shader,
+//      and set those which are found.
+// This does not work extremely efficient, but it's the most practical option
+// for passing builtin parameters onto user provided shaders.
+// Note: May need additional flags related to scene sorting, etcetera.
+struct CProgramFeatures
+{
+	CProgramFeatures() : DriverFlags(0), MaterialFlags(0) { }
+
+	// Driver builtin parameters
+	enum TDriverFlags
+	{
+		// Matrices
+		Matrices								= 0x00000001, 
+
+		// Fog
+		Fog										= 0x00000002, 
+	};
+	uint32 DriverFlags;
+
+	enum TMaterialFlags
+	{
+		/// Use the CMaterial texture stages as the textures for a Pixel Program
+		TextureStages							= 0x00000001, 
+		TextureMatrices							= 0x00000002, 
+	};
+	// Material builtin parameters
+	uint32 MaterialFlags;
+};
+
+// Stucture used to cache the indices of builtin parameters which are used by the drivers
+// Not used for parameters of specific nl3d programs
+struct CProgramIndex
+{
+	enum TName
+	{
+		ModelView, 
+		ModelViewInverse, 
+		ModelViewTranspose, 
+		ModelViewInverseTranspose, 
+
+		Projection, 
+		ProjectionInverse, 
+		ProjectionTranspose, 
+		ProjectionInverseTranspose, 
+
+		ModelViewProjection, 
+		ModelViewProjectionInverse, 
+		ModelViewProjectionTranspose, 
+		ModelViewProjectionInverseTranspose, 
+
+		Fog, 
+
+		NUM_UNIFORMS
+	};
+	static const char *Names[NUM_UNIFORMS];
+	uint Indices[NUM_UNIFORMS];
+};
+
+/**
+ * \brief IProgram
+ * \date 2013-09-07 15:00GMT
+ * \author Jan Boon (Kaetemi)
+ * A generic GPU program
+ */
+class IProgram : public NLMISC::CRefCount
+{
+public:
+	enum TProfile
+	{
+		none = 0,
+
+		// types
+		// Vertex Shader = 0x01
+		// Pixel Shader = 0x02
+		// Geometry Shader = 0x03
+
+		// nel - 0x31,type,bitfield
+		nelvp = 0x31010001, // VP supported by CVertexProgramParser, similar to arbvp1, can be translated to vs_1_1
+
+		// direct3d - 0xD9,type,major,minor
+		// vertex programs
+		vs_1_1 = 0xD9010101,
+		vs_2_0 = 0xD9010200,
+		// vs_2_sw = 0xD9010201, // not sure...
+		// vs_2_x = 0xD9010202, // not sure...
+		// vs_3_0 = 0xD9010300, // not supported
+		// pixel programs
+		ps_1_1 = 0xD9020101, 
+		ps_1_2 = 0xD9020102, 
+		ps_1_3 = 0xD9020103, 
+		ps_1_4 = 0xD9020104, 
+		ps_2_0 = 0xD9020200, 
+		// ps_2_x = 0xD9020201, // not sure...
+		// ps_3_0 = 0xD9020300, // not supported
+
+		// opengl - 0x61,type,bitfield
+		// vertex programs
+		// vp20 = 0x61010001, // NV_vertex_program1_1, outdated
+		arbvp1 = 0x61010002, // ARB_vertex_program
+		vp30 = 0x61010004, // NV_vertex_program2
+		vp40 = 0x61010008, // NV_vertex_program3 + NV_fragment_program3
+		gp4vp = 0x61010010, // NV_gpu_program4
+		gp5vp = 0x61010020, // NV_gpu_program5
+		// pixel programs
+		// fp20 = 0x61020001, // very limited and outdated, unnecessary
+		// fp30 = 0x61020002, // NV_fragment_program, now arbfp1, redundant
+		arbfp1 = 0x61020004, // ARB_fragment_program
+		fp40 = 0x61020008, // NV_fragment_program2, arbfp1 with "OPTION NV_fragment_program2;\n"
+		gp4fp = 0x61020010, // NV_gpu_program4
+		gp5fp = 0x61020020, // NV_gpu_program5
+		// geometry programs
+		gp4gp = 0x61030001, // NV_gpu_program4
+		gp5gp = 0x61030001, // NV_gpu_program5
+
+		// glsl - 0x65,type,version
+		glsl330v = 0x65010330, // GLSL vertex program version 330
+		glsl330f = 0x65020330, // GLSL fragment program version 330
+		glsl330g = 0x65030330, // GLSL geometry program version 330
+	};
+
+	struct CSource : public NLMISC::CRefCount
+	{
+	public:
+		std::string DisplayName;
+
+		/// Minimal required profile for this GPU program
+		IProgram::TProfile Profile;
+
+		const char *SourcePtr;
+		size_t SourceLen;
+		/// Copy the source code string
+		inline void setSource(const std::string &source) { SourceCopy = source; SourcePtr = &SourceCopy[0]; SourceLen = SourceCopy.size(); }
+		inline void setSource(const char *source) { SourceCopy = source; SourcePtr = &SourceCopy[0]; SourceLen = SourceCopy.size(); }
+		/// Set pointer to source code string without copying the string
+		inline void setSourcePtr(const char *sourcePtr, size_t sourceLen) { SourceCopy.clear(); SourcePtr = sourcePtr; SourceLen = sourceLen; }
+		inline void setSourcePtr(const char *sourcePtr) { SourceCopy.clear(); SourcePtr = sourcePtr; SourceLen = strlen(sourcePtr); }
+
+		/// CVertexProgramInfo/CPixelProgramInfo/... NeL features
+		CProgramFeatures Features;
+
+		/// Map with known parameter indices, used for assembly programs
+		std::map<std::string, uint> ParamIndices;
+		
+	private:
+		std::string SourceCopy;
+	};
+
+public:
+	IProgram();
+	virtual ~IProgram();
+
+	// Manage the sources, not allowed after compilation.
+	// Add multiple sources using different profiles, the driver will use the first one it supports.
+	inline size_t getSourceNb() const { return m_Sources.size(); };
+	inline CSource *getSource(size_t i) const { return m_Sources[i]; };
+	inline size_t addSource(CSource *source) { nlassert(!m_Source); m_Sources.push_back(source); return (m_Sources.size() - 1); }
+	inline void removeSource(size_t i) { nlassert(!m_Source); m_Sources.erase(m_Sources.begin() + i); }
+
+	// Get the idx of a parameter (ogl: uniform, d3d: constant, etcetera) by name. Invalid name returns ~0
+	inline uint getUniformIndex(const char *name) const { return m_DrvInfo->getUniformIndex(name); };
+	inline uint getUniformIndex(const std::string &name) const { return m_DrvInfo->getUniformIndex(name.c_str()); };
+	inline uint getUniformIndex(CProgramIndex::TName name) const { return m_Index.Indices[name]; }
+
+	// Get feature information of the current program
+	inline CSource *source() const { return m_Source; };
+	inline const CProgramFeatures &features() const { return m_Source->Features; };
+	inline TProfile profile() const { return m_Source->Profile; }
+
+	// Build feature info, called automatically by the driver after compile succeeds
+	void buildInfo(CSource *source);
+
+	// Override this to build additional info in a subclass
+	virtual void buildInfo();
+
+protected:
+	/// The progam source
+	std::vector<NLMISC::CSmartPtr<CSource> >				m_Sources;
+
+	/// The source used for compilation
+	NLMISC::CSmartPtr<CSource>								m_Source;
+	CProgramIndex										m_Index;
+
+public:
+	/// The driver information. For the driver implementation only.
+	NLMISC::CRefPtr<IProgramDrvInfos>					m_DrvInfo;
+
+}; /* class IProgram */
+
+} /* namespace NL3D */
+
+#endif /* #ifndef NL3D_PROGRAM_H */
+
+/* end of file */

code/nel/include/nel/3d/render_trav.h

@@ -27,6 +27,7 @@
 #include "nel/3d/mesh_block_manager.h"
 #include "nel/3d/shadow_map_manager.h"
 #include "nel/3d/u_scene.h"
+#include "nel/3d/vertex_program.h"
 #include <vector>
 
 
@@ -68,6 +69,41 @@ class   CWaterModel;
 #define	NL3D_SHADOW_MESH_SKIN_MANAGER_MAXVERTICES		3000
 #define	NL3D_SHADOW_MESH_SKIN_MANAGER_NUMVB				8
 
+/// Container for lighted vertex program.
+class CVertexProgramLighted : public CVertexProgram
+{
+public:
+	static const uint MaxLight = 4;
+	static const uint MaxPointLight = (MaxLight - 1);
+	struct CIdxLighted
+	{
+		uint Ambient;
+		uint Diffuse[MaxLight];
+		uint Specular[MaxLight];
+		uint DirOrPos[MaxLight]; // light 0, directional sun; light 1,2,3, omni point light
+		uint EyePosition;
+		uint DiffuseAlpha;
+	};
+	struct CFeaturesLighted
+	{
+		/// Number of point lights that this program is generated for, varies from 0 to 3.
+		uint NumActivePointLights;
+		bool SupportSpecular;
+		bool Normalize;
+		/// Start of constants to use for lighting with assembly shaders.
+		uint CtStartNeLVP;
+	};
+	CVertexProgramLighted() { }
+	virtual ~CVertexProgramLighted() { }
+	virtual void buildInfo();
+	const CIdxLighted &idxLighted() const { return m_IdxLighted; }
+	const CFeaturesLighted &featuresLighted() const { return m_FeaturesLighted; }
+
+protected:
+	CIdxLighted m_IdxLighted;
+	CFeaturesLighted m_FeaturesLighted;
+
+};
 
 
 // ***************************************************************************
@@ -224,7 +260,7 @@ public:
 	// @{
 
 	// Max VP Light setup Infos.
-	enum	{MaxVPLight= 4};
+	enum	{MaxVPLight = CVertexProgramLighted::MaxLight};
 
 	/** reset the lighting setup in the driver (all lights are disabled).
 	 *	called at beginning of traverse(). Must be called by any model (before and after rendering)
@@ -244,7 +280,8 @@ public:
 	 */
 	void		changeLightSetup(CLightContribution	*lightContribution, bool useLocalAttenuation);
 
-
+	/// Must call before beginVPLightSetup
+	void		prepareVPLightSetup();
 	/** setup the driver VP constants to get info from current LightSetup.
 	 *	Only 0..3 Light + SunLights are supported. The VP do NOT support distance/Spot attenuation
 	 *	Also it does not handle World Matrix with non uniform scale correctly since lighting is made in ObjectSpace
@@ -253,7 +290,7 @@ public:
 	 *	\param supportSpecular asitsounds. PointLights and dirLight are localViewer
 	 *	\param invObjectWM the inverse of object matrix: lights are mul by this. Vp compute in object space.
 	 */
-	void		beginVPLightSetup(uint ctStart, bool supportSpecular, const CMatrix &invObjectWM);
+	void		beginVPLightSetup(CVertexProgramLighted *program, const CMatrix &invObjectWM);
 
 	/** change the driver VP LightSetup constants which depends on material.
 	 *  \param excludeStrongest This remove the strongest light from the setup. The typical use is to have it computed by using perpixel lighting.
@@ -299,7 +336,8 @@ public:
 	 *  \param numActivePoinLights tells how many point light from 0 to 3 this VP must handle. NB: the Sun directionnal is not option
 	 *		NB: nlassert(numActiveLights<=MaxVPLight-1).
 	 */
-	static	std::string		getLightVPFragment(uint numActivePointLights, uint ctStart, bool supportSpecular, bool normalize);
+	static	std::string		getLightVPFragmentNeLVP(uint numActivePointLights, uint ctStart, bool supportSpecular, bool normalize);
+	// TODO_VP_GLSL
 
 	/** This returns a reference to a driver light, by its index
 	  * \see getStrongestLightIndex
@@ -381,12 +419,14 @@ private:
 	mutable uint				_StrongestLightIndex;
 	mutable bool				_StrongestLightTouched;
 
+	// Current vp setuped with beginVPLightSetup()
+	NLMISC::CRefPtr<CVertexProgramLighted> _VPCurrent;
 	// Current ctStart setuped with beginVPLightSetup()
-	uint						_VPCurrentCtStart;
+	//uint						_VPCurrentCtStart;
 	// Current num of VP lights enabled.
 	uint						_VPNumLights;
 	// Current support of specular
-	bool						_VPSupportSpecular;
+	// bool						_VPSupportSpecular;
 	// Sum of all ambiant of all lights + ambiantGlobal.
 	NLMISC::CRGBAF				_VPFinalAmbient;
 	// Diffuse/Spec comp of all light / 255.

code/nel/include/nel/3d/scene.h

@@ -827,6 +827,7 @@ private:
 	// common vb for water display
 	CVertexBuffer	 _WaterVB;
 	
+	bool			_RequestParticlesAnimate;
 
 };
 

code/nel/include/nel/3d/shader.h

@@ -1,99 +0,0 @@
-// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
-// Copyright (C) 2010  Winch Gate Property Limited
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#ifndef NL_SHADER_H
-#define NL_SHADER_H
-
-#include "nel/misc/types_nl.h"
-#include "nel/misc/smart_ptr.h"
-#include <list>
-
-
-namespace NL3D {
-
-using NLMISC::CRefCount;
-
-
-class	IDriver;
-
-// List typedef.
-class	IShaderDrvInfos;
-typedef	std::list<IShaderDrvInfos*>		TShaderDrvInfoPtrList;
-typedef	TShaderDrvInfoPtrList::iterator	ItShaderDrvInfoPtrList;
-
-/**
-  * Interface for shader driver infos.
-  */
-class IShaderDrvInfos : public CRefCount
-{
-private:
-	IDriver				*_Driver;
-	ItShaderDrvInfoPtrList		_DriverIterator;
-
-public:
-	IShaderDrvInfos(IDriver	*drv, ItShaderDrvInfoPtrList it) {_Driver= drv; _DriverIterator= it;}
-	// The virtual dtor is important.
-	virtual ~IShaderDrvInfos();
-};
-
-
-/**
- * Shader resource for the driver. It is just a container for a ".fx" text file.
- */
-/* *** IMPORTANT ********************
- * *** IF YOU MODIFY THE STRUCTURE OF THIS CLASS, PLEASE INCREMENT IDriver::InterfaceVersion TO INVALIDATE OLD DRIVER DLL
- * **********************************
- */
-// --------------------------------------------------
-class CShader
-{
-public:
-	CShader();
-	~CShader();
-
-	// Load a shader file
-	bool loadShaderFile (const char *filename);
-
-	// Set the shader text
-	void setText (const char *text);
-
-	// Get the shader text
-	const char *getText () const { return _Text.c_str(); }
-
-	// Set the shader name
-	void setName (const char *name);
-
-	// Get the shader name
-	const char *getName () const { return _Name.c_str(); }
-
-public:
-	// Private. For Driver only.
-	bool								_ShaderChanged;
-	NLMISC::CRefPtr<IShaderDrvInfos>	_DrvInfo;
-private:
-	// The shader
-	std::string					_Text;
-	// The shader name
-	std::string					_Name;
-};
-
-
-} // NL3D
-
-
-#endif // NL_SHADER_H
-
-/* End of shader.h */

code/nel/include/nel/3d/stereo_debugger.h

@@ -0,0 +1,134 @@
+/**
+ * \file stereo_debugger.h
+ * \brief CStereoDebugger
+ * \date 2013-07-03 20:17GMT
+ * \author Jan Boon (Kaetemi)
+ * CStereoDebugger
+ */
+
+/* 
+ * Copyright (C) 2013  by authors
+ * 
+ * This file is part of NL3D.
+ * NL3D is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * NL3D is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
+ * Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public
+ * License along with NL3D.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#if !FINAL_VERSION
+#ifndef NL3D_STEREO_DEBUGGER_H
+#define NL3D_STEREO_DEBUGGER_H
+#include <nel/misc/types_nl.h>
+
+// STL includes
+
+// NeL includes
+#include <nel/misc/smart_ptr.h>
+#include <nel/misc/geom_ext.h>
+
+// Project includes
+#include <nel/3d/stereo_display.h>
+#include <nel/3d/frustum.h>
+#include <nel/3d/viewport.h>
+#include <nel/3d/u_material.h>
+
+#define NL_STEREO_MAX_USER_CAMERAS 8
+
+namespace NL3D {
+
+class ITexture;
+class CTextureUser;
+class CPixelProgram;
+
+/**
+ * \brief CStereoDebugger
+ * \date 2013-07-03 20:17GMT
+ * \author Jan Boon (Kaetemi)
+ * CStereoDebugger
+ */
+class CStereoDebugger : public IStereoDisplay
+{
+public:
+	CStereoDebugger();
+	virtual ~CStereoDebugger();
+
+
+	/// Sets driver and generates necessary render targets
+	virtual void setDriver(NL3D::UDriver *driver);
+	void releaseTextures();
+	void initTextures();
+	void setTextures();
+	void verifyTextures();
+
+	/// Gets the required screen resolution for this device
+	virtual bool getScreenResolution(uint &width, uint &height);
+	/// Set latest camera position etcetera
+	virtual void updateCamera(uint cid, const NL3D::UCamera *camera);
+	/// Get the frustum to use for clipping
+	virtual void getClippingFrustum(uint cid, NL3D::UCamera *camera) const;
+
+	/// Is there a next pass
+	virtual bool nextPass();
+	/// Gets the current viewport
+	virtual const NL3D::CViewport &getCurrentViewport() const;
+	/// Gets the current camera frustum
+	virtual const NL3D::CFrustum &getCurrentFrustum(uint cid) const;
+	/// Gets the current camera frustum
+	virtual void getCurrentFrustum(uint cid, NL3D::UCamera *camera) const;
+	/// Gets the current camera matrix
+	virtual void getCurrentMatrix(uint cid, NL3D::UCamera *camera) const;
+
+	/// At the start of a new render target
+	virtual bool wantClear();	
+	/// The 3D scene
+	virtual bool wantScene();
+	/// Interface within the 3D scene
+	virtual bool wantInterface3D();	
+	/// 2D Interface
+	virtual bool wantInterface2D();
+
+	/// Returns true if a new render target was set, always fase if not using render targets
+	virtual bool beginRenderTarget();
+	/// Returns true if a render target was fully drawn, always false if not using render targets
+	virtual bool endRenderTarget();
+
+
+	static void listDevices(std::vector<CStereoDeviceInfo> &devicesOut);
+
+private:
+	UDriver *m_Driver;
+
+	int m_Stage;
+	int m_SubStage;
+
+	CViewport m_LeftViewport;
+	CViewport m_RightViewport;
+	CFrustum m_Frustum[NL_STEREO_MAX_USER_CAMERAS];
+	CMatrix m_CameraMatrix[NL_STEREO_MAX_USER_CAMERAS];
+
+	NLMISC::CSmartPtr<NL3D::ITexture> m_LeftTex;
+	NL3D::CTextureUser *m_LeftTexU;
+	NLMISC::CSmartPtr<NL3D::ITexture> m_RightTex;
+	NL3D::CTextureUser *m_RightTexU;
+	NL3D::UMaterial m_Mat;
+	NLMISC::CQuadUV m_QuadUV;
+	CPixelProgram *m_PixelProgram;
+
+}; /* class CStereoDebugger */
+
+} /* namespace NL3D */
+
+#endif /* #ifndef NL3D_STEREO_DEBUGGER_H */
+#endif /* #if !FINAL_VERSION */
+
+/* end of file */

code/nel/include/nel/3d/stereo_display.h

@@ -0,0 +1,141 @@
+/**
+ * \file stereo_display.h
+ * \brief IStereoDisplay
+ * \date 2013-06-27 16:29GMT
+ * \author Jan Boon (Kaetemi)
+ * IStereoDisplay
+ */
+
+/* 
+ * Copyright (C) 2013  by authors
+ * 
+ * This file is part of NL3D.
+ * NL3D is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * NL3D is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
+ * Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public
+ * License along with NL3D.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef NL3D_STEREO_DISPLAY_H
+#define NL3D_STEREO_DISPLAY_H
+#include <nel/misc/types_nl.h>
+
+// STL includes
+
+// NeL includes
+#include <nel/misc/smart_ptr.h>
+
+// Project includes
+
+namespace NL3D {
+	
+class UCamera;
+class CViewport;
+class CFrustum;
+class IStereoDisplay;
+class UTexture;
+class UDriver;
+
+class IStereoDeviceFactory : public NLMISC::CRefCount
+{
+public:
+	IStereoDeviceFactory() { }
+	virtual ~IStereoDeviceFactory() { }
+	virtual IStereoDisplay *createDevice() const = 0;
+};
+
+struct CStereoDeviceInfo
+{
+public:
+	enum TStereoDeviceClass
+	{
+		StereoDisplay, 
+		StereoHMD, 
+	};
+	
+	enum TStereoDeviceLibrary
+	{
+		NeL3D, 
+		OVR, 
+		LibVR, 
+		OpenHMD, 
+	};
+	
+	NLMISC::CSmartPtr<IStereoDeviceFactory> Factory;
+	
+	TStereoDeviceLibrary Library;
+	TStereoDeviceClass Class;
+	std::string Manufacturer;
+	std::string ProductName;
+	std::string Serial; // A unique device identifier
+};
+
+/**
+ * \brief IStereoDisplay
+ * \date 2013-06-27 16:29GMT
+ * \author Jan Boon (Kaetemi)
+ * IStereoDisplay
+ */
+class IStereoDisplay
+{
+public:
+	IStereoDisplay();
+	virtual ~IStereoDisplay();
+
+	/// Sets driver and generates necessary render targets
+	virtual void setDriver(NL3D::UDriver *driver) = 0;
+	
+	/// Gets the required screen resolution for this device
+	virtual bool getScreenResolution(uint &width, uint &height) = 0;
+	/// Set latest camera position etcetera
+	virtual void updateCamera(uint cid, const NL3D::UCamera *camera) = 0;
+	/// Get the frustum to use for clipping
+	virtual void getClippingFrustum(uint cid, NL3D::UCamera *camera) const = 0;
+
+	/// Is there a next pass
+	virtual bool nextPass() = 0;
+	/// Gets the current viewport
+	virtual const NL3D::CViewport &getCurrentViewport() const = 0;
+	/// Gets the current camera frustum
+	virtual const NL3D::CFrustum &getCurrentFrustum(uint cid) const = 0;
+	/// Gets the current camera frustum
+	virtual void getCurrentFrustum(uint cid, NL3D::UCamera *camera) const = 0;
+	/// Gets the current camera matrix
+	virtual void getCurrentMatrix(uint cid, NL3D::UCamera *camera) const = 0;
+
+	/// At the start of a new render target
+	virtual bool wantClear() = 0;	
+	/// The 3D scene
+	virtual bool wantScene() = 0;
+	/// Interface within the 3D scene
+	virtual bool wantInterface3D() = 0;	
+	/// 2D Interface
+	virtual bool wantInterface2D() = 0;
+
+	/// Returns true if a new render target was set, always fase if not using render targets
+	virtual bool beginRenderTarget() = 0;
+	/// Returns true if a render target was fully drawn, always false if not using render targets
+	virtual bool endRenderTarget() = 0;
+	
+	static const char *getLibraryName(CStereoDeviceInfo::TStereoDeviceLibrary library);
+	static void listDevices(std::vector<CStereoDeviceInfo> &devicesOut);
+	static IStereoDisplay *createDevice(const CStereoDeviceInfo &deviceInfo);
+	static void releaseUnusedLibraries();
+	static void releaseAllLibraries();
+	
+}; /* class IStereoDisplay */
+
+} /* namespace NL3D */
+
+#endif /* #ifndef NL3D_STEREO_DISPLAY_H */
+
+/* end of file */

code/nel/include/nel/3d/stereo_hmd.h

@@ -0,0 +1,73 @@
+/**
+ * \file stereo_hmd.h
+ * \brief IStereoHMD
+ * \date 2013-06-27 16:30GMT
+ * \author Jan Boon (Kaetemi)
+ * IStereoHMD
+ */
+
+/* 
+ * Copyright (C) 2013  by authors
+ * 
+ * This file is part of NL3D.
+ * NL3D is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * NL3D is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
+ * Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public
+ * License along with NL3D.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef NL3D_STEREO_HMD_H
+#define NL3D_STEREO_HMD_H
+#include <nel/misc/types_nl.h>
+
+// STL includes
+
+// NeL includes
+
+// Project includes
+#include <nel/3d/stereo_display.h>
+
+namespace NL3D {
+
+/**
+ * \brief IStereoHMD
+ * \date 2013-06-27 16:30GMT
+ * \author Jan Boon (Kaetemi)
+ * IStereoHMD
+ */
+class IStereoHMD : public IStereoDisplay
+{
+public:
+	IStereoHMD();
+	virtual ~IStereoHMD();
+	
+	/// Get the HMD orientation
+	virtual NLMISC::CQuat getOrientation() const = 0;
+
+	/// Get GUI center (1 = width, 1 = height, 0 = center)
+	virtual void getInterface2DShift(uint cid, float &x, float &y, float distance) const = 0;
+	
+	/// Set the head model, eye position relative to orientation point
+	virtual void setEyePosition(const NLMISC::CVector &v) = 0;
+	/// Get the head model, eye position relative to orientation point
+	virtual const NLMISC::CVector &getEyePosition() const = 0;
+
+	/// Set the scale of the game in units per meter
+	virtual void setScale(float s) = 0;
+	
+}; /* class IStereoHMD */
+
+} /* namespace NL3D */
+
+#endif /* #ifndef NL3D_STEREO_HMD_H */
+
+/* end of file */

code/nel/include/nel/3d/stereo_libvr.h

@@ -0,0 +1,160 @@
+/**
+ * \file stereo_libvr.h
+ * \brief CStereoLibVR
+ * \date 2013-08-19 19:17MT
+ * \author Thibaut Girka (ThibG)
+ * CStereoLibVR
+ */
+
+/* 
+ * Copyright (C) 2013  by authors
+ * 
+ * This file is part of NL3D.
+ * NL3D is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * NL3D is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
+ * Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public
+ * License along with NL3D.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef NL3D_STEREO_LIBVR_H
+#define NL3D_STEREO_LIBVR_H
+
+#ifdef HAVE_LIBVR
+
+#include <nel/misc/types_nl.h>
+
+// STL includes
+
+// NeL includes
+#include <nel/misc/smart_ptr.h>
+#include <nel/misc/geom_ext.h>
+
+// Project includes
+#include <nel/3d/stereo_hmd.h>
+#include <nel/3d/frustum.h>
+#include <nel/3d/viewport.h>
+#include <nel/3d/u_material.h>
+
+namespace NL3D {
+
+class ITexture;
+class CTextureUser;
+class CStereoLibVRDevicePtr;
+class CStereoLibVRDeviceHandle;
+class CPixelProgram;
+
+#define NL_STEREO_MAX_USER_CAMERAS 8
+
+/**
+ * \brief CStereoOVR
+ * \date 2013-06-25 22:22GMT
+ * \author Jan Boon (Kaetemi)
+ * CStereoOVR
+ */
+class CStereoLibVR : public IStereoHMD
+{
+public:
+	CStereoLibVR(const CStereoLibVRDeviceHandle *handle);
+	virtual ~CStereoLibVR();
+
+	/// Sets driver and generates necessary render targets
+	virtual void setDriver(NL3D::UDriver *driver);
+
+	/// Gets the required screen resolution for this device
+	virtual bool getScreenResolution(uint &width, uint &height);
+	/// Set latest camera position etcetera
+	virtual void updateCamera(uint cid, const NL3D::UCamera *camera);
+	/// Get the frustum to use for clipping
+	virtual void getClippingFrustum(uint cid, NL3D::UCamera *camera) const;
+
+	/// Is there a next pass
+	virtual bool nextPass();
+	/// Gets the current viewport
+	virtual const NL3D::CViewport &getCurrentViewport() const;
+	/// Gets the current camera frustum
+	virtual const NL3D::CFrustum &getCurrentFrustum(uint cid) const;
+	/// Gets the current camera frustum
+	virtual void getCurrentFrustum(uint cid, NL3D::UCamera *camera) const;
+	/// Gets the current camera matrix
+	virtual void getCurrentMatrix(uint cid, NL3D::UCamera *camera) const;
+
+	/// At the start of a new render target
+	virtual bool wantClear();
+	/// The 3D scene
+	virtual bool wantScene();
+	/// Interface within the 3D scene
+	virtual bool wantInterface3D();	
+	/// 2D Interface
+	virtual bool wantInterface2D();
+
+	/// Returns true if a new render target was set, always fase if not using render targets
+	virtual bool beginRenderTarget();
+	/// Returns true if a render target was fully drawn, always false if not using render targets
+	virtual bool endRenderTarget();
+
+
+	/// Get the HMD orientation
+	virtual NLMISC::CQuat getOrientation() const;
+
+	/// Get GUI center (1 = width, 1 = height, 0 = center)
+	virtual void getInterface2DShift(uint cid, float &x, float &y, float distance) const;
+
+	/// Set the head model, eye position relative to orientation point
+	virtual void setEyePosition(const NLMISC::CVector &v);
+	/// Get the head model, eye position relative to orientation point
+	virtual const NLMISC::CVector &getEyePosition() const;
+
+	/// Set the scale of the game in units per meter
+	virtual void setScale(float s);
+
+
+	static void listDevices(std::vector<CStereoDeviceInfo> &devicesOut);
+	static bool isLibraryInUse();
+	static void releaseLibrary();
+
+
+	/// Calculates internal camera information based on the reference camera
+	void initCamera(uint cid, const NL3D::UCamera *camera);
+	/// Checks if the device used by this class was actually created
+	bool isDeviceCreated();
+
+private:
+	CStereoLibVRDevicePtr *m_DevicePtr;
+	int m_Stage;
+	int m_SubStage;
+	CViewport m_LeftViewport;
+	CViewport m_RightViewport;
+	CFrustum m_ClippingFrustum[NL_STEREO_MAX_USER_CAMERAS];
+	CFrustum m_LeftFrustum[NL_STEREO_MAX_USER_CAMERAS];
+	CFrustum m_RightFrustum[NL_STEREO_MAX_USER_CAMERAS];
+	CMatrix m_CameraMatrix[NL_STEREO_MAX_USER_CAMERAS];
+	mutable bool m_OrientationCached;
+	mutable NLMISC::CQuat m_OrientationCache;
+	UDriver *m_Driver;
+	NLMISC::CSmartPtr<NL3D::ITexture> m_BarrelTex;
+	NL3D::CTextureUser *m_BarrelTexU;
+	NL3D::UMaterial m_BarrelMat;
+	NLMISC::CQuadUV m_BarrelQuadLeft;
+	NLMISC::CQuadUV m_BarrelQuadRight;
+	CPixelProgram *m_PixelProgram;
+	NLMISC::CVector m_EyePosition;
+	float m_Scale;
+
+}; /* class CStereoLibVR */
+
+} /* namespace NL3D */
+
+#endif /* HAVE_LIBVR */
+
+#endif /* #ifndef NL3D_STEREO_LIBVR_H */
+
+/* end of file */

code/nel/include/nel/3d/stereo_ovr.h

@@ -0,0 +1,176 @@
+/**
+ * \file stereo_ovr.h
+ * \brief CStereoOVR
+ * \date 2013-06-25 22:22GMT
+ * \author Jan Boon (Kaetemi)
+ * CStereoOVR
+ */
+
+/* 
+ * Copyright (C) 2013  by authors
+ * 
+ * This file is part of NL3D.
+ * NL3D is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * NL3D is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
+ * Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public
+ * License along with NL3D.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ * 
+ * Linking this library statically or dynamically with other modules
+ * is making a combined work based on this library.  Thus, the terms
+ * and conditions of the GNU General Public License cover the whole
+ * combination.
+ * 
+ * As a special exception, the copyright holders of this library give
+ * you permission to link this library with the Oculus SDK to produce
+ * an executable, regardless of the license terms of the Oculus SDK,
+ * and distribute linked combinations including the two, provided that
+ * you also meet the terms and conditions of the license of the Oculus
+ * SDK.  You must obey the GNU General Public License in all respects
+ * for all of the code used other than the Oculus SDK.  If you modify
+ * this file, you may extend this exception to your version of the
+ * file, but you are not obligated to do so.  If you do not wish to do
+ * so, delete this exception statement from your version.
+ */
+
+#ifndef NL3D_STEREO_OVR_H
+#define NL3D_STEREO_OVR_H
+
+#ifdef HAVE_LIBOVR
+
+#include <nel/misc/types_nl.h>
+
+// STL includes
+
+// NeL includes
+#include <nel/misc/smart_ptr.h>
+#include <nel/misc/geom_ext.h>
+
+// Project includes
+#include <nel/3d/stereo_hmd.h>
+#include <nel/3d/frustum.h>
+#include <nel/3d/viewport.h>
+#include <nel/3d/u_material.h>
+
+namespace NL3D {
+
+class ITexture;
+class CTextureUser;
+class CStereoOVRDevicePtr;
+class CStereoOVRDeviceHandle;
+class CPixelProgramOVR;
+
+#define NL_STEREO_MAX_USER_CAMERAS 8
+
+/**
+ * \brief CStereoOVR
+ * \date 2013-06-25 22:22GMT
+ * \author Jan Boon (Kaetemi)
+ * CStereoOVR
+ */
+class CStereoOVR : public IStereoHMD
+{
+public:
+	CStereoOVR(const CStereoOVRDeviceHandle *handle);
+	virtual ~CStereoOVR();
+
+	/// Sets driver and generates necessary render targets
+	virtual void setDriver(NL3D::UDriver *driver);
+
+	/// Gets the required screen resolution for this device
+	virtual bool getScreenResolution(uint &width, uint &height);
+	/// Set latest camera position etcetera
+	virtual void updateCamera(uint cid, const NL3D::UCamera *camera);
+	/// Get the frustum to use for clipping
+	virtual void getClippingFrustum(uint cid, NL3D::UCamera *camera) const;
+
+	/// Is there a next pass
+	virtual bool nextPass();
+	/// Gets the current viewport
+	virtual const NL3D::CViewport &getCurrentViewport() const;
+	/// Gets the current camera frustum
+	virtual const NL3D::CFrustum &getCurrentFrustum(uint cid) const;
+	/// Gets the current camera frustum
+	virtual void getCurrentFrustum(uint cid, NL3D::UCamera *camera) const;
+	/// Gets the current camera matrix
+	virtual void getCurrentMatrix(uint cid, NL3D::UCamera *camera) const;
+
+	/// At the start of a new render target
+	virtual bool wantClear();	
+	/// The 3D scene
+	virtual bool wantScene();
+	/// Interface within the 3D scene
+	virtual bool wantInterface3D();	
+	/// 2D Interface
+	virtual bool wantInterface2D();
+
+	/// Returns true if a new render target was set, always fase if not using render targets
+	virtual bool beginRenderTarget();
+	/// Returns true if a render target was fully drawn, always false if not using render targets
+	virtual bool endRenderTarget();
+
+
+	/// Get the HMD orientation
+	virtual NLMISC::CQuat getOrientation() const;
+
+	/// Get GUI center (1 = width, 1 = height, 0 = center)
+	virtual void getInterface2DShift(uint cid, float &x, float &y, float distance) const;
+
+	/// Set the head model, eye position relative to orientation point
+	virtual void setEyePosition(const NLMISC::CVector &v);
+	/// Get the head model, eye position relative to orientation point
+	virtual const NLMISC::CVector &getEyePosition() const;
+
+	/// Set the scale of the game in units per meter
+	virtual void setScale(float s);
+
+
+	static void listDevices(std::vector<CStereoDeviceInfo> &devicesOut);
+	static bool isLibraryInUse();
+	static void releaseLibrary();
+
+
+	/// Calculates internal camera information based on the reference camera
+	void initCamera(uint cid, const NL3D::UCamera *camera);
+	/// Checks if the device used by this class was actually created
+	bool isDeviceCreated();
+
+private:
+	CStereoOVRDevicePtr *m_DevicePtr;
+	int m_Stage;
+	int m_SubStage;
+	CViewport m_LeftViewport;
+	CViewport m_RightViewport;
+	CFrustum m_ClippingFrustum[NL_STEREO_MAX_USER_CAMERAS];
+	CFrustum m_LeftFrustum[NL_STEREO_MAX_USER_CAMERAS];
+	CFrustum m_RightFrustum[NL_STEREO_MAX_USER_CAMERAS];
+	CMatrix m_CameraMatrix[NL_STEREO_MAX_USER_CAMERAS];
+	mutable bool m_OrientationCached;
+	mutable NLMISC::CQuat m_OrientationCache;
+	UDriver *m_Driver;
+	NLMISC::CSmartPtr<NL3D::ITexture> m_BarrelTex;
+	NL3D::CTextureUser *m_BarrelTexU;
+	NL3D::UMaterial m_BarrelMat;
+	NLMISC::CQuadUV m_BarrelQuadLeft;
+	NLMISC::CQuadUV m_BarrelQuadRight;
+	NLMISC::CRefPtr<CPixelProgramOVR> m_PixelProgram;
+	NLMISC::CVector m_EyePosition;
+	float m_Scale;
+
+}; /* class CStereoOVR */
+
+} /* namespace NL3D */
+
+#endif /* HAVE_LIBOVR */
+
+#endif /* #ifndef NL3D_STEREO_OVR_H */
+
+/* end of file */

code/nel/include/nel/3d/u_driver.h

@@ -168,6 +168,7 @@ public:
 	 */
 	// @{
 	virtual void			disableHardwareVertexProgram()=0;
+	virtual void			disableHardwarePixelProgram()=0;
 	virtual void			disableHardwareVertexArrayAGP()=0;
 	virtual void			disableHardwareTextureShader()=0;
 	// @}
@@ -672,13 +673,6 @@ public:
 	 */
 	virtual void			forceTextureResize(uint divisor)=0;
 
-	/** Sets enforcement of native fragment programs. This is by default enabled.
-	 *
-	 * \param nativeOnly If set to false, fragment programs don't need to be native to stay loaded,
-	 * 	                 otherwise (aka if true) they will be purged.
-	 */
-	virtual void			forceNativeFragmentPrograms(bool nativeOnly) = 0;
-
 	/** Setup monitor color properties.
 	  *
 	  * Return false if setup failed.

code/nel/include/nel/3d/vegetable_manager.h

@@ -48,6 +48,7 @@ class	CVegetableLightEx;
 // default distance is 60 meters.
 #define	NL3D_VEGETABLE_DEFAULT_DIST_MAX			60.f
 
+class CVertexProgramVeget;
 
 // ***************************************************************************
 /**
@@ -306,7 +307,8 @@ private:
 	// The same, but no VBHard.
 	CVegetableVBAllocator							_VBSoftAllocator[CVegetableVBAllocator::VBTypeCount];
 	// Vertex Program. One VertexProgram for each rdrPass (with / without fog)
-	CVertexProgram									*_VertexProgram[NL3D_VEGETABLE_NRDRPASS][2];
+	CSmartPtr<CVertexProgramVeget>					_VertexProgram[NL3D_VEGETABLE_NRDRPASS][2];
+	CRefPtr<CVertexProgramVeget>					_ActiveVertexProgram;
 
 
 	// Material. Useful for texture and alphaTest
@@ -342,7 +344,7 @@ private:
 
 
 	/// setup the vertexProgram constants.
-	void					setupVertexProgramConstants(IDriver *driver);
+	void					setupVertexProgramConstants(IDriver *driver, bool fogEnabled);
 
 
 	/** swap the RdrPass type (hard or soft) of the rdrPass of an instance group.

code/nel/include/nel/3d/vertex_program.h

@@ -19,90 +19,24 @@
 
 #include "nel/misc/types_nl.h"
 #include "nel/misc/smart_ptr.h"
+#include "nel/3d/program.h"
 
 #include <list>
 
-
 namespace NL3D {
 
-// List typedef.
+class CVertexProgram : public IProgram
-class	IDriver;
-class	IVertexProgramDrvInfos;
-typedef	std::list<IVertexProgramDrvInfos*>	TVtxPrgDrvInfoPtrList;
-typedef	TVtxPrgDrvInfoPtrList::iterator		ItVtxPrgDrvInfoPtrList;
-
-// Class for interaction of vertex program with Driver.
-// IVertexProgramDrvInfos represent the real data of the vertex program, stored into the driver (eg: just a GLint for opengl).
-class IVertexProgramDrvInfos : public NLMISC::CRefCount
-{
-private:
-	IDriver					*_Driver;
-	ItVtxPrgDrvInfoPtrList	_DriverIterator;
-
-public:
-	IVertexProgramDrvInfos (IDriver *drv, ItVtxPrgDrvInfoPtrList it);
-	// The virtual dtor is important.
-	virtual ~IVertexProgramDrvInfos(void);
-};
-
-
-/**
- * This class is a vertex program.
- *
- * D3D / OPENGL compatibility notes:
- * ---------------------------------
- *
- * To make your program compatible with D3D and OPENGL nel drivers, please follow thoses directives to write your vertex programs
- *
- * - Use only v[0], v[1] etc.. syntax for input registers. Don't use v0, v1 or v[OPOS] etc..
- * - Use only c[0], c[1] etc.. syntax for constant registers. Don't use c0, c1 etc..
- * - Use only o[HPOS], o[COL0] etc.. syntax for output registers. Don't use oPos, oD0 etc..
- * - Use only uppercase for registers R1, R2 etc.. Don't use lowercase r1, r2 etc..
- * - Use a semicolon to delineate instructions.
- * - Use ARL instruction to load the adress register and not MOV.
- * - Don't use the NOP instruction.
- * - Don't use macros.
- *
- * -> Thoses programs work without any change under OpenGL.
- * -> Direct3D driver implementation will have to modify the syntax on the fly before the setup like this:
- *   - "v[0]" must be changed in "v0" etc..
- *   - "o[HPOS]" must be changed in oPos etc..
- *   - Semicolon must be changed in line return character.
- *   - ARL instruction must be changed in MOV.
- *
- * Behaviour of LOG may change depending on implementation: You can only expect to have dest.z = log2(abs(src.w)).
- * LIT may or may not clamp the specular exponent to [-128, 128] (not done when EXT_vertex_shader is used for example ..)
- *
- * Depending on the implementation, some optimizations can be achieved by masking the unused output values of instructions
- * as LIT, EXPP ..
- *
- * \author Cyril 'Hulud' Corvazier
- * \author Nevrax France
- * \date 2001
- */
-class CVertexProgram : public NLMISC::CRefCount
 {
 public:
-
 	/// Constructor
-	CVertexProgram (const char* program);
+	CVertexProgram();
+	CVertexProgram(const char *nelvp);
 
 	/// Destructor
 	virtual ~CVertexProgram ();
 
-	/// Get the program
-	const std::string&	getProgram () const { return _Program; };
-
-private:
-	/// The progam
-	std::string									_Program;
-
-public:
-	/// The driver information. For the driver implementation only.
-	NLMISC::CRefPtr<IVertexProgramDrvInfos>		_DrvInfo;
 };
 
-
 } // NL3D
 
 

code/nel/include/nel/3d/vertex_program_parse.h

@@ -21,6 +21,40 @@
 
 #include <vector>
 
+/**
+ * This class is a vertex program.
+ *
+ * D3D / OPENGL compatibility notes:
+ * ---------------------------------
+ *
+ * To make your program compatible with D3D and OPENGL nel drivers, please follow thoses directives to write your vertex programs
+ *
+ * - Use only v[0], v[1] etc.. syntax for input registers. Don't use v0, v1 or v[OPOS] etc..
+ * - Use only c[0], c[1] etc.. syntax for constant registers. Don't use c0, c1 etc..
+ * - Use only o[HPOS], o[COL0] etc.. syntax for output registers. Don't use oPos, oD0 etc..
+ * - Use only uppercase for registers R1, R2 etc.. Don't use lowercase r1, r2 etc..
+ * - Use a semicolon to delineate instructions.
+ * - Use ARL instruction to load the adress register and not MOV.
+ * - Don't use the NOP instruction.
+ * - Don't use macros.
+ *
+ * -> Thoses programs work without any change under OpenGL.
+ * -> Direct3D driver implementation will have to modify the syntax on the fly before the setup like this:
+ *   - "v[0]" must be changed in "v0" etc..
+ *   - "o[HPOS]" must be changed in oPos etc..
+ *   - Semicolon must be changed in line return character.
+ *   - ARL instruction must be changed in MOV.
+ *
+ * Behaviour of LOG may change depending on implementation: You can only expect to have dest.z = log2(abs(src.w)).
+ * LIT may or may not clamp the specular exponent to [-128, 128] (not done when EXT_vertex_shader is used for example ..)
+ *
+ * Depending on the implementation, some optimizations can be achieved by masking the unused output values of instructions
+ * as LIT, EXPP ..
+ *
+ * \author Cyril 'Hulud' Corvazier
+ * \author Nevrax France
+ * \date 2001
+ */
 
 /// Swizzle of an operand in a vertex program
 struct CVPSwizzle

code/nel/include/nel/3d/water_env_map.h

@@ -61,7 +61,7 @@ public:
 	// Get envmap 2D texture (after projection of cube map)
 	ITexture			*getEnvMap2D() const { return _Env2D; }
 	// tmp for debug : render test mesh with current model / view matrixs
-	void				renderTestMesh(IDriver &driver);
+	// void				renderTestMesh(IDriver &driver);
 	// set constant alpha of envmap
 	void				setAlpha(uint8 alpha) { _Alpha = alpha; }
 	uint8				getAlpha() const { return _Alpha; }

code/nel/include/nel/3d/water_shape.h

@@ -49,6 +49,29 @@ const NLMISC::CClassId WaveMakerModelClassId =  NLMISC::CClassId(0x16da3356, 0x7
 const uint WATER_VERTEX_HARD_SIZE = sizeof(float[3]);
 const uint WATER_VERTEX_SOFT_SIZE = sizeof(float[5]);
 
+// VP Water No Wave
+class CVertexProgramWaterVPNoWave : public CVertexProgram
+{
+public:
+	struct CIdx
+	{
+		uint BumpMap0Scale;
+		uint BumpMap0Offset;
+		uint BumpMap1Scale;
+		uint BumpMap1Offset;
+		uint ObserverHeight;
+		uint ScaleReflectedRay;
+		uint DiffuseMapVector0;
+		uint DiffuseMapVector1;
+	};
+	CVertexProgramWaterVPNoWave(bool diffuse);
+	virtual ~CVertexProgramWaterVPNoWave() { }
+	virtual void buildInfo();
+	inline const CIdx &idx() const { return m_Idx; }
+private:
+	CIdx m_Idx;
+	bool m_Diffuse;
+};
 
 /**
  * A water shape.
@@ -247,17 +270,17 @@ private:
 	static bool								_GridSizeTouched;
 
 	//
-	static std::auto_ptr<CVertexProgram>	_VertexProgramBump1;
+	/*static NLMISC::CSmartPtr<CVertexProgram>	_VertexProgramBump1;
-	static std::auto_ptr<CVertexProgram>	_VertexProgramBump2;
+	static NLMISC::CSmartPtr<CVertexProgram>	_VertexProgramBump2;
 	//
-	static std::auto_ptr<CVertexProgram>	_VertexProgramBump1Diffuse;
+	static NLMISC::CSmartPtr<CVertexProgram>	_VertexProgramBump1Diffuse;
-	static std::auto_ptr<CVertexProgram>	_VertexProgramBump2Diffuse;
+	static NLMISC::CSmartPtr<CVertexProgram>	_VertexProgramBump2Diffuse;
 	//
-	static std::auto_ptr<CVertexProgram>	_VertexProgramNoBump;
+	static NLMISC::CSmartPtr<CVertexProgram>	_VertexProgramNoBump;
-	static std::auto_ptr<CVertexProgram>	_VertexProgramNoBumpDiffuse;
+	static NLMISC::CSmartPtr<CVertexProgram>	_VertexProgramNoBumpDiffuse;*/
 	//
-	static std::auto_ptr<CVertexProgram>    _VertexProgramNoWave;
+	static NLMISC::CSmartPtr<CVertexProgramWaterVPNoWave>    _VertexProgramNoWave;
-	static std::auto_ptr<CVertexProgram>    _VertexProgramNoWaveDiffuse;
+	static NLMISC::CSmartPtr<CVertexProgramWaterVPNoWave>    _VertexProgramNoWaveDiffuse;
 };
 
 

code/nel/include/nel/georges/load_form.h

@@ -109,7 +109,7 @@ struct TLoadFormDicoEntry
 	}
 };
 */
-const uint32		PACKED_SHEET_HEADER = 'PKSH';
+const uint32		PACKED_SHEET_HEADER = NELID("PKSH");
 const uint32		PACKED_SHEET_VERSION = 5;
 // This Version may be used if you want to use the serialVersion() system in loadForm()
 const uint32		PACKED_SHEET_VERSION_COMPATIBLE = 0;

code/nel/include/nel/misc/cdb_branch.h

@@ -21,6 +21,8 @@
 
 #include "cdb.h"
 
+#define NL_CDB_OPTIMIZE_PREDICT 1
+
 namespace NLMISC{
 
 /**
@@ -247,6 +249,10 @@ protected:
 
 	/// called by clear
 	void			removeAllBranchObserver();
+
+#if NL_CDB_OPTIMIZE_PREDICT
+	CRefPtr<ICDBNode>		_PredictNode;
+#endif
 };
 
 }

code/nel/include/nel/misc/fast_floor.h

@@ -19,6 +19,7 @@
 
 #include "types_nl.h"
 #include <cmath>
+#include <nel/misc/debug.h>
 
 namespace NLMISC
 {

code/nel/include/nel/misc/stream.h

@@ -53,6 +53,13 @@ class	CMemStream;
 #  endif
 #  define NLMISC_BSWAP64(src) (src) = (((src)>>56)&0xFF) | ((((src)>>48)&0xFF)<<8) | ((((src)>>40)&0xFF)<<16) | ((((src)>>32)&0xFF)<<24) | ((((src)>>24)&0xFF)<<32) | ((((src)>>16)&0xFF)<<40) | ((((src)>>8)&0xFF)<<48) | (((src)&0xFF)<<56)
 
+// convert a 4 characters string to uint32
+#ifdef NL_LITTLE_ENDIAN
+#	define NELID(x) (uint32((x[0] << 24) | (x[1] << 16) | (x[2] << 8) | (x[3])))
+#else
+#	define NELID(x) (uint32((x[3] << 24) | (x[2] << 16) | (x[1] << 8) | (x[0])))
+#endif
+
 // ======================================================================================================
 /**
  * Stream Exception.

code/nel/samples/3d/nel_qt/nel_qt.cfg

@@ -6,7 +6,7 @@ GraphicsDriver       = "OpenGL";
 SoundDriver          = "OpenAL";
 SoundDevice          = "";
 LanguageCode         = "en";
-QtStyle              = "Cleanlooks";
+QtStyle              = "";
 FontName             = "andbasr.ttf";
 FontShadow           = 1;
 BackgroundColor      = {

code/nel/src/3d/CMakeLists.txt

@@ -153,8 +153,6 @@ SOURCE_GROUP(Driver FILES
         ../../include/nel/3d/scene.h
         scene_group.cpp
         ../../include/nel/3d/scene_group.h
-        shader.cpp
-        ../../include/nel/3d/shader.h
         texture.cpp
         ../../include/nel/3d/texture.h
         vertex_buffer.cpp
@@ -164,7 +162,15 @@ SOURCE_GROUP(Driver FILES
         vertex_program.cpp
         ../../include/nel/3d/vertex_program.h
         vertex_program_parse.cpp
-        ../../include/nel/3d/vertex_program_parse.h)
+        ../../include/nel/3d/vertex_program_parse.h
+        pixel_program.cpp
+        ../../include/nel/3d/pixel_program.h
+        geometry_program.cpp
+        ../../include/nel/3d/geometry_program.h
+        program.cpp
+        ../../include/nel/3d/program.h
+        gpu_program_params.cpp
+        ../../include/nel/3d/gpu_program_params.h)
 
 SOURCE_GROUP(Font FILES
         computed_string.cpp
@@ -686,12 +692,24 @@ SOURCE_GROUP(Shadows FILES
         ../../include/nel/3d/shadow_map_manager.h
         shadow_poly_receiver.cpp
         ../../include/nel/3d/shadow_poly_receiver.h)
+SOURCE_GROUP(Stereo FILES
+		stereo_display.cpp
+        ../../include/nel/3d/stereo_display.h
+		stereo_hmd.cpp
+        ../../include/nel/3d/stereo_hmd.h
+		stereo_ovr.cpp
+		stereo_ovr_fp.cpp
+        ../../include/nel/3d/stereo_ovr.h
+		stereo_libvr.cpp
+        ../../include/nel/3d/stereo_libvr.h
+		stereo_debugger.cpp
+		../../include/nel/3d/stereo_debugger.h)
 
 NL_TARGET_LIB(nel3d ${HEADERS} ${SRC})
 
-INCLUDE_DIRECTORIES(${LIBXML2_INCLUDE_DIR} ${FREETYPE_INCLUDE_DIRS})
+INCLUDE_DIRECTORIES(${LIBXML2_INCLUDE_DIR} ${FREETYPE_INCLUDE_DIRS} ${LIBOVR_INCLUDE_DIR} ${LIBVR_INCLUDE_DIR})
 
-TARGET_LINK_LIBRARIES(nel3d nelmisc ${FREETYPE_LIBRARY})
+TARGET_LINK_LIBRARIES(nel3d nelmisc ${FREETYPE_LIBRARIES} ${LIBOVR_LIBRARIES} ${LIBVR_LIBRARY})
 SET_TARGET_PROPERTIES(nel3d PROPERTIES LINK_INTERFACE_LIBRARIES "")
 NL_DEFAULT_PROPS(nel3d "NeL, Library: NeL 3D")
 NL_ADD_RUNTIME_FLAGS(nel3d)
@@ -701,6 +719,9 @@ NL_ADD_LIB_SUFFIX(nel3d)
 
 ADD_DEFINITIONS(${LIBXML2_DEFINITIONS})
 
+ADD_DEFINITIONS(${LIBOVR_DEFINITIONS})
+ADD_DEFINITIONS(${LIBVR_DEFINITIONS})
+
 IF(WITH_PCH)
   ADD_NATIVE_PRECOMPILED_HEADER(nel3d ${CMAKE_CURRENT_SOURCE_DIR}/std3d.h ${CMAKE_CURRENT_SOURCE_DIR}/std3d.cpp)
 ENDIF(WITH_PCH)

code/nel/src/3d/animation.cpp

@@ -89,8 +89,8 @@ void CAnimation::serial (NLMISC::IStream& f)
 	nlassert(_IdByChannelId.empty());
 
 	// Serial a header
-	f.serialCheck ((uint32)'_LEN');
+	f.serialCheck (NELID("_LEN"));
-	f.serialCheck ((uint32)'MINA');
+	f.serialCheck (NELID("MINA"));
 
 	// Serial a version
 	sint version=f.serialVersion (2);

code/nel/src/3d/animation_set.cpp

@@ -185,9 +185,9 @@ void CAnimationSet::serial (NLMISC::IStream& f)
 	nlassert(!_AnimHeaderOptimisation);
 
 	// Serial an header
-	f.serialCheck ((uint32)'_LEN');
+	f.serialCheck (NELID("_LEN"));
-	f.serialCheck ((uint32)'MINA');
+	f.serialCheck (NELID("MINA"));
-	f.serialCheck ((uint32)'TES_');
+	f.serialCheck (NELID("TES_"));
 
 	// Serial a version
 	uint	ver= f.serialVersion (1);

code/nel/src/3d/bloom_effect.cpp

@@ -55,13 +55,18 @@ static const char *TextureOffset =
 	END \n";
 
 
-static CVertexProgram TextureOffsetVertexProgram(TextureOffset);
+static NLMISC::CSmartPtr<CVertexProgram> TextureOffsetVertexProgram;
 
 
 //-----------------------------------------------------------------------------------------------------------
 
 CBloomEffect::CBloomEffect()
 {
+	if (!TextureOffsetVertexProgram)
+	{
+		TextureOffsetVertexProgram = new CVertexProgram(TextureOffset);
+	}
+
 	_Driver = NULL;
 	_Scene = NULL;
 	_SquareBloom = true;
@@ -285,6 +290,8 @@ void CBloomEffect::initBloom() // clientcfg
 	if(!_Init)
 		init();
 
+	_OriginalRenderTarget = static_cast<CDriverUser *>(_Driver)->getDriver()->getRenderTarget();
+
 	// if window resize, reinitialize textures
 	if(_WndWidth!=_Driver->getWindowWidth() || _WndHeight!=_Driver->getWindowHeight())
 	{
@@ -349,13 +356,15 @@ void CBloomEffect::initBloom() // clientcfg
 		}
 	}
 
-	NL3D::CTextureUser *txt = (_InitBloomEffect) ? (new CTextureUser(_InitText)) : (new CTextureUser());
+	if (!_OriginalRenderTarget)
-	if(!((CDriverUser *) _Driver)->setRenderTarget(*txt, 0, 0, _WndWidth, _WndHeight))
+	{
+		NL3D::CTextureUser txt = (_InitBloomEffect) ? (CTextureUser(_InitText)) : (CTextureUser());
+		if(!(static_cast<CDriverUser *>(_Driver)->setRenderTarget(txt, 0, 0, _WndWidth, _WndHeight)))
 		{
 			nlwarning("setRenderTarget return false with initial texture for bloom effect\n");
 			return;
 		}
-	delete txt;
+	}
 }
 
 //-----------------------------------------------------------------------------------------------------------
@@ -371,13 +380,13 @@ void CBloomEffect::endBloom() // clientcfg
 	if(_Driver->getWindowWidth()==0 || _Driver->getWindowHeight()==0)
 		return;
 
-	CTextureUser *txt1 = (_InitBloomEffect) ? (new CTextureUser(_InitText)) : (new CTextureUser());
+	CTextureUser txt1 = _OriginalRenderTarget ? CTextureUser(_OriginalRenderTarget) : ((_InitBloomEffect) ? (CTextureUser(_InitText)) : (CTextureUser()));
-	CTextureUser *txt2 = new CTextureUser(_BlurFinalTex);
+	CTextureUser txt2(_BlurFinalTex);
-	CRect *rect1 = new CRect(0, 0, _WndWidth, _WndHeight);
+	CRect rect1(0, 0, _WndWidth, _WndHeight);
-	CRect *rect2 = new CRect(0, 0, _BlurWidth, _BlurHeight);
+	CRect rect2(0, 0, _BlurWidth, _BlurHeight);
 	// stretch rect
-	((CDriverUser *) _Driver)->stretchRect(_Scene, *txt1 , *rect1,
+	((CDriverUser *) _Driver)->stretchRect(_Scene, txt1 , rect1,
-		*txt2, *rect2);
+		txt2, rect2);
 
 	// horizontal blur pass
 	doBlur(true);
@@ -387,10 +396,6 @@ void CBloomEffect::endBloom() // clientcfg
 
 	// apply blur with a blend operation
 	applyBlur();
-	delete txt1;
-	delete txt2;
-	delete rect1;
-	delete rect2;
 }
 
 //-----------------------------------------------------------------------------------------------------------
@@ -399,16 +404,30 @@ void CBloomEffect::applyBlur()
 {
 	NL3D::IDriver *drvInternal = ((CDriverUser *) _Driver)->getDriver();
 
-	// in opengl, display in init texture
+	/*if (_OriginalRenderTarget)
-	if(_InitBloomEffect)
 	{
-		CTextureUser *txt = new CTextureUser(_InitText);
+		CTextureUser txt(_OriginalRenderTarget);
-		if(!((CDriverUser *) _Driver)->setRenderTarget(*txt, 0, 0, _WndWidth, _WndHeight))
+		if(!(static_cast<CDriverUser *>(_Driver)->setRenderTarget(txt, 0, 0, _WndWidth, _WndHeight)))
+		{
+			nlwarning("setRenderTarget return false with original render target for bloom effect\n");
+			return;
+		}
+	}
+	// in opengl, display in init texture
+	else if(_InitBloomEffect)
+	{
+		CTextureUser txt(_InitText);
+		if(!(static_cast<CDriverUser *>(_Driver)->setRenderTarget(txt, 0, 0, _WndWidth, _WndHeight)))
 		{
 			nlwarning("setRenderTarget return false with initial texture for bloom effect\n");
 			return;
 		}
-		delete txt;
+	}*/
+	CTextureUser txtApply = _OriginalRenderTarget ? CTextureUser(_OriginalRenderTarget) : ((_InitBloomEffect) ? (CTextureUser(_InitText)) : (CTextureUser()));
+	if(!(static_cast<CDriverUser *>(_Driver)->setRenderTarget(txtApply, 0, 0, _WndWidth, _WndHeight)))
+	{
+		nlwarning("setRenderTarget return false with initial texture for bloom effect\n");
+		return;
 	}
 
 	// display blur texture
@@ -429,9 +448,9 @@ void CBloomEffect::applyBlur()
 	}
 
 	// initialize vertex program
-	drvInternal->activeVertexProgram(&TextureOffsetVertexProgram);
+	drvInternal->activeVertexProgram(TextureOffsetVertexProgram);
-	drvInternal->setConstant(8, 255.f, 255.f, 255.f, 255.f);
+	drvInternal->setUniform4f(IDriver::VertexProgram, 8, 255.f, 255.f, 255.f, 255.f);
-	drvInternal->setConstant(9, 0.0f, 0.f, 0.f, 1.f);
+	drvInternal->setUniform4f(IDriver::VertexProgram, 9, 0.0f, 0.f, 0.f, 1.f);
 
 	// initialize blur material
 	UMaterial displayBlurMat;
@@ -463,7 +482,9 @@ void CBloomEffect::applyBlur()
 
 void CBloomEffect::endInterfacesDisplayBloom() // clientcfg
 {
-	if(_InitBloomEffect)
+	// Render from render target to screen if necessary.
+	// Don't do this when the blend was done to the screen or when rendering to a user provided rendertarget.
+	if ((_OriginalRenderTarget.getPtr() == NULL) && _InitBloomEffect)
 	{
 		if(!_Driver->supportBloomEffect() || !_Init)
 			return;
@@ -475,9 +496,8 @@ void CBloomEffect::endInterfacesDisplayBloom() // clientcfg
 			return;
 
 		NL3D::IDriver *drvInternal = ((CDriverUser *) _Driver)->getDriver();
-		CTextureUser *txt = new CTextureUser();
+		CTextureUser txtNull;
-		((CDriverUser *)_Driver)->setRenderTarget(*txt, 0, 0, 0, 0);
+		((CDriverUser *)_Driver)->setRenderTarget(txtNull, 0, 0, 0, 0);
-		delete txt;
 
 		// initialize texture coordinates
 		float newU = drvInternal->isTextureRectangle(_InitText) ? (float)_WndWidth : 1.f;
@@ -497,6 +517,8 @@ void CBloomEffect::endInterfacesDisplayBloom() // clientcfg
 		_Driver->drawQuad(_DisplayQuad, _DisplayInitMat);
 		_Driver->setMatrixMode3D(pCam);
 	}
+
+	_OriginalRenderTarget = NULL;
 }
 
 
@@ -523,19 +545,18 @@ void CBloomEffect::doBlur(bool horizontalBlur)
 	}
 
 	NL3D::IDriver *drvInternal = ((CDriverUser *) _Driver)->getDriver();
-	CTextureUser *txt = new CTextureUser(endTexture);
+	CTextureUser txt(endTexture);
 	// initialize render target
-	if(!((CDriverUser *) _Driver)->setRenderTarget(*txt, 0, 0, _BlurWidth, _BlurHeight))
+	if(!((CDriverUser *) _Driver)->setRenderTarget(txt, 0, 0, _BlurWidth, _BlurHeight))
 	{
 		nlwarning("setRenderTarget return false with blur texture for bloom effect\n");
 		return;
 	}
-	delete txt;
 
 	// initialize vertex program
-	drvInternal->activeVertexProgram(&TextureOffsetVertexProgram);
+	drvInternal->activeVertexProgram(TextureOffsetVertexProgram);
-	drvInternal->setConstant(8, 255.f, 255.f, 255.f, 255.f);
+	drvInternal->setUniform4f(IDriver::VertexProgram, 8, 255.f, 255.f, 255.f, 255.f);
-	drvInternal->setConstant(9, 0.0f, 0.f, 0.f, 1.f);
+	drvInternal->setUniform4f(IDriver::VertexProgram, 9, 0.0f, 0.f, 0.f, 1.f);
 
 	// set several decal constants in order to obtain in the render target texture a mix of color
 	// of a texel and its neighbored texels on the axe of the pass.
@@ -554,10 +575,10 @@ void CBloomEffect::doBlur(bool horizontalBlur)
 		decalR = 1.f;
 		decal2R = 2.f;
 	}
-	drvInternal->setConstant(10, (decalR/(float)_BlurWidth)*blurVec.x,		(decalR/(float)_BlurHeight)*blurVec.y, 0.f, 0.f);
+	drvInternal->setUniform2f(IDriver::VertexProgram, 10, (decalR/(float)_BlurWidth)*blurVec.x,		(decalR/(float)_BlurHeight)*blurVec.y);
-	drvInternal->setConstant(11, (decal2R/(float)_BlurWidth)*blurVec.x,		(decal2R/(float)_BlurHeight)*blurVec.y, 0.f, 0.f);
+	drvInternal->setUniform2f(IDriver::VertexProgram, 11, (decal2R/(float)_BlurWidth)*blurVec.x,		(decal2R/(float)_BlurHeight)*blurVec.y);
-	drvInternal->setConstant(12, (decalL/(float)_BlurWidth)*blurVec.x,		(decalL/(float)_BlurHeight)*blurVec.y, 0.f, 0.f);
+	drvInternal->setUniform2f(IDriver::VertexProgram, 12, (decalL/(float)_BlurWidth)*blurVec.x,		(decalL/(float)_BlurHeight)*blurVec.y);
-	drvInternal->setConstant(13, (decal2L/(float)_BlurWidth)*blurVec.x,		(decal2L/(float)_BlurHeight)*blurVec.y, 0.f, 0.f);
+	drvInternal->setUniform2f(IDriver::VertexProgram, 13, (decal2L/(float)_BlurWidth)*blurVec.x,		(decal2L/(float)_BlurHeight)*blurVec.y);
 
 	// initialize material textures
 	CMaterial * matObject = _BlurMat.getObjectPtr();
@@ -579,10 +600,9 @@ void CBloomEffect::doBlur(bool horizontalBlur)
 
 	// disable render target and vertex program
 	drvInternal->activeVertexProgram(NULL);
-	txt = new CTextureUser();
+	CTextureUser cu;
-	((CDriverUser *)_Driver)->setRenderTarget(*txt, 0, 0, 0, 0);
+	((CDriverUser *)_Driver)->setRenderTarget(cu, 0, 0, 0, 0);
 	_Driver->setMatrixMode3D(pCam);
-	delete txt;
 }
 
 }; // NL3D

code/nel/src/3d/computed_string.cpp

@@ -21,6 +21,7 @@
 #include "nel/3d/index_buffer.h"
 #include "nel/3d/material.h"
 #include "nel/3d/frustum.h"
+#include "nel/3d/viewport.h"
 
 #include "nel/misc/smart_ptr.h"
 #include "nel/misc/debug.h"
@@ -85,6 +86,10 @@ void CComputedString::render2D (IDriver& driver,
 	// get window size
 	uint32	wndWidth, wndHeight;
 	driver.getWindowSize(wndWidth, wndHeight);
+	CViewport vp;
+	driver.getViewport(vp);
+	wndWidth = (uint32)((float)wndWidth * vp.getWidth());
+	wndHeight = (uint32)((float)wndHeight * vp.getHeight());
 	// scale to window size.
 	x*= wndWidth;
 	z*= wndHeight;
@@ -242,8 +247,8 @@ void CComputedString::render2DClip (IDriver& driver, CRenderStringBuffer &rdrBuf
 		uint lastIndex = 0;
 		for(uint i=0;i<numVerts;i++)
 		{
-			if(count==4){
+			if(count==4)
-
+			{
 				if(!LetterColors.empty())
 				{
 					if(LetterColors.getIndex(lastIndex)==i/4)

code/nel/src/3d/driver.cpp

@@ -20,7 +20,6 @@
 
 #include "nel/misc/types_nl.h"
 #include "nel/3d/driver.h"
-#include "nel/3d/shader.h"
 #include "nel/3d/vertex_buffer.h"
 #include "nel/misc/algo.h"
 
@@ -33,7 +32,7 @@ namespace NL3D
 {
 
 // ***************************************************************************
-const uint32 IDriver::InterfaceVersion = 0x6b; // added anisotropic filter
+const uint32 IDriver::InterfaceVersion = 0x6d; // gpu program interface
 
 // ***************************************************************************
 IDriver::IDriver() : _SyncTexDrvInfos( "IDriver::_SyncTexDrvInfos" )
@@ -58,7 +57,7 @@ IDriver::~IDriver()
 	nlassert(_MatDrvInfos.size()==0);
 	nlassert(_VBDrvInfos.size()==0);
 	nlassert(_IBDrvInfos.size()==0);
-	nlassert(_VtxPrgDrvInfos.size()==0);
+	nlassert(_GPUPrgDrvInfos.size()==0);
 }
 
 
@@ -95,14 +94,6 @@ bool		IDriver::release(void)
 		delete *itmat;
 	}
 
-	// Release Shader drv.
-	ItShaderDrvInfoPtrList		itshd;
-	while( (itshd = _ShaderDrvInfos.begin()) != _ShaderDrvInfos.end() )
-	{
-		// NB: at IShader deletion, this->_MatDrvInfos is updated (entry deleted);
-		delete *itshd;
-	}
-
 	// Release VBs drv.
 	ItVBDrvInfoPtrList		itvb;
 	while( (itvb = _VBDrvInfos.begin()) != _VBDrvInfos.end() )
@@ -119,12 +110,12 @@ bool		IDriver::release(void)
 		delete *itib;
 	}
 
-	// Release VtxPrg drv.
+	// Release GPUPrg drv.
-	ItVtxPrgDrvInfoPtrList		itVtxPrg;
+	ItGPUPrgDrvInfoPtrList		itGPUPrg;
-	while( (itVtxPrg = _VtxPrgDrvInfos.begin()) != _VtxPrgDrvInfos.end() )
+	while( (itGPUPrg = _GPUPrgDrvInfos.begin()) != _GPUPrgDrvInfos.end() )
 	{
-		// NB: at IVertexProgramDrvInfos deletion, this->_VtxPrgDrvInfos is updated (entry deleted);
+		// NB: at IVertexProgramDrvInfos deletion, this->_GPUPrgDrvInfos is updated (entry deleted);
-		delete *itVtxPrg;
+		delete *itGPUPrg;
 	}
 
 	return true;
@@ -249,14 +240,9 @@ void			IDriver::removeMatDrvInfoPtr(ItMatDrvInfoPtrList shaderIt)
 	_MatDrvInfos.erase(shaderIt);
 }
 // ***************************************************************************
-void			IDriver::removeShaderDrvInfoPtr(ItShaderDrvInfoPtrList shaderIt)
+void			IDriver::removeGPUPrgDrvInfoPtr(ItGPUPrgDrvInfoPtrList gpuPrgDrvInfoIt)
 {
-	_ShaderDrvInfos.erase(shaderIt);
+	_GPUPrgDrvInfos.erase(gpuPrgDrvInfoIt);
-}
-// ***************************************************************************
-void			IDriver::removeVtxPrgDrvInfoPtr(ItVtxPrgDrvInfoPtrList vtxPrgDrvInfoIt)
-{
-	_VtxPrgDrvInfos.erase(vtxPrgDrvInfoIt);
 }
 
 // ***************************************************************************

code/nel/src/3d/driver/direct3d/driver_direct3d.cpp

@@ -193,6 +193,11 @@ CDriverD3D::CDriverD3D()
 #else // NL_DISABLE_HARDWARE_VERTEX_PROGAM
 	_DisableHardwareVertexProgram = false;
 #endif // NL_DISABLE_HARDWARE_VERTEX_PROGAM
+#ifdef NL_DISABLE_HARDWARE_PIXEL_PROGAM
+	_DisableHardwarePixelProgram = true;
+#else // NL_DISABLE_HARDWARE_PIXEL_PROGAM
+	_DisableHardwarePixelProgram = false;
+#endif // NL_DISABLE_HARDWARE_PIXEL_PROGAM
 #ifdef NL_DISABLE_HARDWARE_VERTEX_ARRAY_AGP
 	_DisableHardwareVertexArrayAGP = true;
 #else // NL_DISABLE_HARDWARE_VERTEX_ARRAY_AGP
@@ -1546,13 +1551,15 @@ bool CDriverD3D::setDisplay(nlWindow wnd, const GfxMode& mode, bool show, bool r
 #endif // NL_FORCE_TEXTURE_STAGE_COUNT
 
 	_VertexProgram = !_DisableHardwareVertexProgram && ((caps.VertexShaderVersion&0xffff) >= 0x0100);
-	_PixelShader = !_DisableHardwarePixelShader && (caps.PixelShaderVersion&0xffff) >= 0x0101;
+	_PixelProgramVersion = _DisableHardwareVertexProgram ? 0x0000 : caps.PixelShaderVersion & 0xffff;
+	nldebug("Pixel Program Version: %i.%i", (uint32)((_PixelProgramVersion & 0xFF00) >> 8), (uint32)(_PixelProgramVersion & 0xFF));
+	_PixelProgram = _PixelProgramVersion >= 0x0101;
 	_MaxVerticesByVertexBufferHard = caps.MaxVertexIndex;
 	_MaxLight = caps.MaxActiveLights;
 
 	if(_MaxLight > 0xFF) _MaxLight = 3;
 
-	if (_PixelShader)
+	if (_PixelProgram)
 	{
 		_MaxNumPerStageConstantLighted = _NbNeLTextureStages;
 		_MaxNumPerStageConstantUnlighted = _NbNeLTextureStages;
@@ -1703,6 +1710,13 @@ bool CDriverD3D::release()
 	// Call IDriver::release() before, to destroy textures, shaders and VBs...
 	IDriver::release();
 
+	ItShaderDrvInfoPtrList		itshd;
+	while( (itshd = _ShaderDrvInfos.begin()) != _ShaderDrvInfos.end() )
+	{
+		// NB: at IShader deletion, this->_MatDrvInfos is updated (entry deleted);
+		delete *itshd;
+	}
+
 	_SwapBufferCounter = 0;
 
 	if (_QuadIB)
@@ -2016,6 +2030,8 @@ bool CDriverD3D::swapBuffers()
 
 	// Reset vertex program
 	setVertexProgram (NULL, NULL);
+	// Reset pixel program
+	setPixelShader (NULL);
 
 	if (_VBHardProfiling)
 	{
@@ -2987,7 +3003,7 @@ bool CDriverD3D::stretchRect(ITexture * srcText, NLMISC::CRect &srcRect, ITextur
 
 bool CDriverD3D::supportBloomEffect() const
 {
-	return isVertexProgramSupported();
+	return supportVertexProgram(CVertexProgram::nelvp);
 }
 
 // ***************************************************************************
@@ -3330,9 +3346,9 @@ uint COcclusionQueryD3D::getVisibleCount()
 }
 
 // ***************************************************************************
-bool CDriverD3D::isWaterShaderSupported() const
+bool CDriverD3D::supportWaterShader() const
 {
-	H_AUTO_D3D(CDriverD3D_isWaterShaderSupported);
+	H_AUTO_D3D(CDriverD3D_supportWaterShader);
 	return _PixelShaderVersion >= D3DPS_VERSION(1, 1);
 }
 
@@ -3618,7 +3634,7 @@ void CDriverD3D::CVertexProgramPtrState::apply(CDriverD3D *driver)
 void CDriverD3D::CPixelShaderPtrState::apply(CDriverD3D *driver)
 {
 	H_AUTO_D3D(CDriverD3D_CPixelShaderPtrState);
-	if (!driver->supportPixelShaders()) return;
+	if (!driver->_PixelProgram) return;
 	driver->_DeviceInterface->SetPixelShader(PixelShader);
 }
 

code/nel/src/3d/driver/direct3d/driver_direct3d.h

@@ -35,7 +35,6 @@
 #include "nel/3d/scissor.h"
 #include "nel/3d/driver.h"
 #include "nel/3d/material.h"
-#include "nel/3d/shader.h"
 #include "nel/3d/vertex_buffer.h"
 #include "nel/3d/index_buffer.h"
 #include "nel/3d/ptr_set.h"
@@ -181,6 +180,75 @@ public:
 };
 
 
+using NLMISC::CRefCount;
+
+
+class	IDriver;
+class CDriverD3D;
+
+// List typedef.
+class	IShaderDrvInfos;
+typedef	std::list<IShaderDrvInfos*>		TShaderDrvInfoPtrList;
+typedef	TShaderDrvInfoPtrList::iterator	ItShaderDrvInfoPtrList;
+
+/**
+  * Interface for shader driver infos.
+  */
+class IShaderDrvInfos : public CRefCount
+{
+private:
+	CDriverD3D				*_Driver;
+	ItShaderDrvInfoPtrList		_DriverIterator;
+
+public:
+	IShaderDrvInfos(CDriverD3D	*drv, ItShaderDrvInfoPtrList it) {_Driver= drv; _DriverIterator= it;}
+	// The virtual dtor is important.
+	virtual ~IShaderDrvInfos();
+};
+
+
+/**
+ * Shader resource for the driver. It is just a container for a ".fx" text file.
+ */
+/* *** IMPORTANT ********************
+ * *** IF YOU MODIFY THE STRUCTURE OF THIS CLASS, PLEASE INCREMENT IDriver::InterfaceVersion TO INVALIDATE OLD DRIVER DLL
+ * **********************************
+ */
+// --------------------------------------------------
+class CD3DShaderFX
+{
+public:
+	CD3DShaderFX();
+	~CD3DShaderFX();
+
+	// Load a shader file
+	bool loadShaderFile (const char *filename);
+
+	// Set the shader text
+	void setText (const char *text);
+
+	// Get the shader text
+	const char *getText () const { return _Text.c_str(); }
+
+	// Set the shader name
+	void setName (const char *name);
+
+	// Get the shader name
+	const char *getName () const { return _Name.c_str(); }
+
+public:
+	// Private. For Driver only.
+	bool								_ShaderChanged;
+	NLMISC::CRefPtr<IShaderDrvInfos>	_DrvInfo;
+private:
+	// The shader
+	std::string					_Text;
+	// The shader name
+	std::string					_Name;
+};
+
+
+
 // ***************************************************************************
 class CTextureDrvInfosD3D : public ITextureDrvInfos
 {
@@ -229,16 +297,48 @@ public:
 };
 
 
+
 // ***************************************************************************
-class CVertexProgamDrvInfosD3D : public IVertexProgramDrvInfos
+class CVertexProgamDrvInfosD3D : public IProgramDrvInfos
 {
 public:
 
 	// The shader
 	IDirect3DVertexShader9	*Shader;
 
-	CVertexProgamDrvInfosD3D(IDriver *drv, ItVtxPrgDrvInfoPtrList it);
+	CVertexProgamDrvInfosD3D(IDriver *drv, ItGPUPrgDrvInfoPtrList it);
 	~CVertexProgamDrvInfosD3D();
+
+	virtual uint getUniformIndex(const char *name) const
+	{ 
+		std::map<std::string, uint>::const_iterator it = ParamIndices.find(name);
+		if (it != ParamIndices.end()) return it->second; 
+		return ~0;
+	};
+
+	std::map<std::string, uint> ParamIndices;
+};
+ 
+
+// ***************************************************************************
+class CPixelProgramDrvInfosD3D : public IProgramDrvInfos
+{
+public:
+ 
+	// The shader
+	IDirect3DPixelShader9	*Shader;
+
+	CPixelProgramDrvInfosD3D(IDriver *drv, ItGPUPrgDrvInfoPtrList it);
+	~CPixelProgramDrvInfosD3D();
+
+	virtual uint getUniformIndex(const char *name) const
+	{ 
+		std::map<std::string, uint>::const_iterator it = ParamIndices.find(name);
+		if (it != ParamIndices.end()) return it->second; 
+		return ~0;
+	};
+
+	std::map<std::string, uint> ParamIndices;
 };
 
 
@@ -333,7 +433,7 @@ public:
 	// Scalar handles
 	D3DXHANDLE				ScalarFloatHandle[MaxShaderTexture];
 
-	CShaderDrvInfosD3D(IDriver *drv, ItShaderDrvInfoPtrList it);
+	CShaderDrvInfosD3D(CDriverD3D *drv, ItShaderDrvInfoPtrList it);
 	virtual ~CShaderDrvInfosD3D();
 };
 
@@ -773,13 +873,13 @@ public:
 
 	// Driver parameters
 	virtual void			disableHardwareVertexProgram();
+	virtual void			disableHardwarePixelProgram();
 	virtual void			disableHardwareIndexArrayAGP();
 	virtual void			disableHardwareVertexArrayAGP();
 	virtual void			disableHardwareTextureShader();
 	virtual void			forceDXTCCompression(bool dxtcComp);
 	virtual void			setAnisotropicFilter(sint filter);
 	virtual void			forceTextureResize(uint divisor);
-	virtual void			forceNativeFragmentPrograms(bool /* nativeOnly */) {} // ignored
 
 	// Driver information
 	virtual uint			getNumAdapter() const;
@@ -841,6 +941,7 @@ public:
 	// todo hulud d3d buffers
 	virtual void			getZBufferPart (std::vector<float>  &zbuffer, NLMISC::CRect &rect);
 	virtual bool			setRenderTarget (ITexture *tex, uint32 x, uint32 y, uint32 width, uint32 height, uint32 mipmapLevel, uint32 cubeFace);
+	virtual ITexture		*getRenderTarget() const;
 	virtual bool			copyTargetToTexture (ITexture *tex, uint32 offsetx, uint32 offsety, uint32 x, uint32 y, uint32 width,
 													uint32 height, uint32 mipmapLevel);
 	virtual bool			getRenderTargetSize (uint32 &width, uint32 &height);
@@ -959,9 +1060,9 @@ public:
 	virtual bool			supportTextureShaders() const {return false;};
 	virtual	bool			supportMADOperator() const;
 	// todo hulud d3d adressing mode
-	virtual bool			isWaterShaderSupported() const;
+	virtual bool			supportWaterShader() const;
 	// todo hulud d3d adressing mode
-	virtual bool			isTextureAddrModeSupported(CMaterial::TTexAddressingMode /* mode */) const {return false;};
+	virtual bool			supportTextureAddrMode(CMaterial::TTexAddressingMode /* mode */) const {return false;};
 	// todo hulud d3d adressing mode
 	virtual void			setMatrix2DForTextureOffsetAddrMode(const uint /* stage */, const float /* mat */[4]) {}
 
@@ -991,18 +1092,133 @@ public:
 	virtual void			setupMaterialPass(uint pass);
 	virtual void			endMaterialMultiPass();
 
-	// Vertex program
+
-	virtual bool			isVertexProgramSupported () const;
+
+	
+
+
+	/// \name Vertex Program
+	// @{
+
+	// Order of preference
+	// - activeVertexProgram
+	// - CMaterial pass[n] VP (uses activeVertexProgram, but does not override if one already set by code)
+	// - default generic VP that mimics fixed pipeline / no VP with fixed pipeline
+
+	/**
+	  * Does the driver supports vertex program, but emulated by CPU ?
+	  */
 	virtual bool			isVertexProgramEmulated() const;
+
+	/** Return true if the driver supports the specified vertex program profile.
+	  */
+	virtual bool			supportVertexProgram(CVertexProgram::TProfile profile) const;
+
+	/** Compile the given vertex program, return if successful.
+	  * If a vertex program was set active before compilation, 
+	  * the state of the active vertex program is undefined behaviour afterwards.
+	  */
+	virtual bool			compileVertexProgram(CVertexProgram *program);
+
+	/** Set the active vertex program. This will override vertex programs specified in CMaterial render calls.
+	  * Also used internally by setupMaterial(CMaterial) when getVertexProgram returns NULL.
+	  * The vertex program is activated immediately.
+	  */
 	virtual bool			activeVertexProgram(CVertexProgram *program);
-	virtual void			setConstant (uint index, float, float, float, float);
+	// @}
-	virtual void			setConstant (uint index, double, double, double, double);
+
-	virtual void			setConstant (uint index, const NLMISC::CVector& value);
+
-	virtual void			setConstant (uint index, const NLMISC::CVectorD& value);
+
-	virtual void			setConstant (uint index, uint num, const float *src);
+	/// \name Pixel Program
-	virtual void			setConstant (uint index, uint num, const double *src);
+	// @{
-	virtual void			setConstantMatrix (uint index, IDriver::TMatrix matrix, IDriver::TTransform transform);
+
-	virtual void			setConstantFog (uint index);
+	// Order of preference
+	// - activePixelProgram
+	// - CMaterial pass[n] PP (uses activePixelProgram, but does not override if one already set by code)
+	// - PP generated from CMaterial (uses activePixelProgram, but does not override if one already set by code)
+
+	/** Return true if the driver supports the specified pixel program profile.
+	  */
+	virtual bool			supportPixelProgram(CPixelProgram::TProfile profile) const;
+
+	/** Compile the given pixel program, return if successful.
+	  * If a pixel program was set active before compilation, 
+	  * the state of the active pixel program is undefined behaviour afterwards.
+	  */
+	virtual bool			compilePixelProgram(CPixelProgram *program);
+
+	/** Set the active pixel program. This will override pixel programs specified in CMaterial render calls.
+	  * Also used internally by setupMaterial(CMaterial) when getPixelProgram returns NULL.
+	  * The pixel program is activated immediately.
+	  */
+	virtual bool			activePixelProgram(CPixelProgram *program);
+	// @}
+
+
+
+	/// \name Geometry Program
+	// @{
+
+	// Order of preference
+	// - activeGeometryProgram
+	// - CMaterial pass[n] PP (uses activeGeometryProgram, but does not override if one already set by code)
+	// - none
+
+	/** Return true if the driver supports the specified pixel program profile.
+	  */
+	virtual bool			supportGeometryProgram(CGeometryProgram::TProfile profile) const { return false; }
+
+	/** Compile the given pixel program, return if successful.
+	  * If a pixel program was set active before compilation, 
+	  * the state of the active pixel program is undefined behaviour afterwards.
+	  */
+	virtual bool			compileGeometryProgram(CGeometryProgram *program) { return false; }
+
+	/** Set the active pixel program. This will override pixel programs specified in CMaterial render calls.
+	  * Also used internally by setupMaterial(CMaterial) when getGeometryProgram returns NULL.
+	  * The pixel program is activated immediately.
+	  */
+	virtual bool			activeGeometryProgram(CGeometryProgram *program) { return false; }
+	// @}
+
+
+
+	/// \name Program parameters
+	// @{
+	// Set parameters
+	virtual void			setUniform1f(TProgram program, uint index, float f0);
+	virtual void			setUniform2f(TProgram program, uint index, float f0, float f1);
+	virtual void			setUniform3f(TProgram program, uint index, float f0, float f1, float f2);
+	virtual void			setUniform4f(TProgram program, uint index, float f0, float f1, float f2, float f3);
+	virtual void			setUniform1i(TProgram program, uint index, sint32 i0);
+	virtual void			setUniform2i(TProgram program, uint index, sint32 i0, sint32 i1);
+	virtual void			setUniform3i(TProgram program, uint index, sint32 i0, sint32 i1, sint32 i2);
+	virtual void			setUniform4i(TProgram program, uint index, sint32 i0, sint32 i1, sint32 i2, sint32 i3);
+	virtual void			setUniform1ui(TProgram program, uint index, uint32 ui0);
+	virtual void			setUniform2ui(TProgram program, uint index, uint32 ui0, uint32 ui1);
+	virtual void			setUniform3ui(TProgram program, uint index, uint32 ui0, uint32 ui1, uint32 ui2);
+	virtual void			setUniform4ui(TProgram program, uint index, uint32 ui0, uint32 ui1, uint32 ui2, uint32 ui3);
+	virtual void			setUniform3f(TProgram program, uint index, const NLMISC::CVector& v);
+	virtual void			setUniform4f(TProgram program, uint index, const NLMISC::CVector& v, float f3);
+	virtual void			setUniform4f(TProgram program, uint index, const NLMISC::CRGBAF& rgba);
+	virtual void			setUniform4x4f(TProgram program, uint index, const NLMISC::CMatrix& m);
+	virtual void			setUniform4fv(TProgram program, uint index, size_t num, const float *src);
+	virtual void			setUniform4iv(TProgram program, uint index, size_t num, const sint32 *src);
+	virtual void			setUniform4uiv(TProgram program, uint index, size_t num, const uint32 *src);
+	// Set builtin parameters
+	virtual void			setUniformMatrix(TProgram program, uint index, TMatrix matrix, TTransform transform);
+	virtual void			setUniformFog(TProgram program, uint index);
+    // Set feature parameters
+	virtual bool			setUniformDriver(TProgram program); // set all driver-specific features params (based on program->features->DriverFlags)
+	virtual bool			setUniformMaterial(TProgram program, CMaterial &material); // set all material-specific feature params (based on program->features->MaterialFlags)
+	virtual void			setUniformParams(TProgram program, CGPUProgramParams &params); // set all user-provided params from the storage
+	virtual bool			isUniformProgramState() { return false; }
+	// @}
+
+
+
+
+
 	virtual void			enableVertexProgramDoubleSidedColor(bool doubleSided);
 	virtual bool		    supportVertexProgramDoubleSidedColor() const;
 
@@ -1021,7 +1237,7 @@ public:
 	  * ColorOp[n] = DISABLE;
 	  * AlphaOp[n] = DISABLE;
     */
-	virtual bool			activeShader(CShader *shd);
+	bool			activeShader(CD3DShaderFX *shd);
 
 	// Bench
 	virtual void startBench (bool wantStandardDeviation = false, bool quick = false, bool reset = true);
@@ -1040,8 +1256,6 @@ public:
 
 	uint32					getMaxVertexIndex() const { return _MaxVertexIndex; }
 
-	bool					supportPixelShaders() const { return _PixelShader; }
-
 		// *** Inline info
 	uint					inlGetNumTextStages() const { return _NbNeLTextureStages; }
 
@@ -1892,12 +2106,21 @@ public:
 		return d3dtex;
 	}
 
+	// Get the d3dtext mirror of an existing setuped pixel program.
+	static	inline CPixelProgramDrvInfosD3D*	getPixelProgramD3D(CPixelProgram& pixelProgram)
+	{
+		H_AUTO_D3D(CDriverD3D_getPixelProgramD3D);
+		CPixelProgramDrvInfosD3D*	d3dPixelProgram;
+		d3dPixelProgram = (CPixelProgramDrvInfosD3D*)(IProgramDrvInfos*)(pixelProgram.m_DrvInfo);
+		return d3dPixelProgram;
+	}
+
 	// Get the d3dtext mirror of an existing setuped vertex program.
 	static	inline CVertexProgamDrvInfosD3D*	getVertexProgramD3D(CVertexProgram& vertexProgram)
 	{
 		H_AUTO_D3D(CDriverD3D_getVertexProgramD3D);
 		CVertexProgamDrvInfosD3D*	d3dVertexProgram;
-		d3dVertexProgram = (CVertexProgamDrvInfosD3D*)(IVertexProgramDrvInfos*)(vertexProgram._DrvInfo);
+		d3dVertexProgram = (CVertexProgamDrvInfosD3D*)(IProgramDrvInfos*)(vertexProgram.m_DrvInfo);
 		return d3dVertexProgram;
 	}
 
@@ -1943,7 +2166,7 @@ public:
 	void releaseInternalShaders();
 	bool setShaderTexture (uint textureHandle, ITexture *texture, CFXCache *cache);
 
-	bool validateShader(CShader *shader);
+	bool validateShader(CD3DShaderFX *shader);
 
 	void activePass (uint pass)
 	{
@@ -2080,6 +2303,8 @@ private:
 
 	void findNearestFullscreenVideoMode();
 
+	TShaderDrvInfoPtrList	_ShaderDrvInfos;
+
 	// Windows
 	std::string				_WindowClass;
 	HWND					_HWnd;
@@ -2197,8 +2422,10 @@ private:
 	bool					_ForceDXTCCompression:1;
 	bool					_TextureCubeSupported;
 	bool					_VertexProgram;
-	bool					_PixelShader;
+	bool					_PixelProgram;
+	uint16					_PixelProgramVersion;
 	bool					_DisableHardwareVertexProgram;
+	bool					_DisableHardwarePixelProgram;
 	bool					_DisableHardwareVertexArrayAGP;
 	bool					_DisableHardwareIndexArrayAGP;
 	bool					_DisableHardwarePixelShader;
@@ -2316,6 +2543,9 @@ private:
 	// The last vertex buffer needs vertex color
 	bool					_FogEnabled;
 
+	NLMISC::CRefPtr<CVertexProgram> _VertexProgramUser;
+	NLMISC::CRefPtr<CPixelProgram> _PixelProgramUser;
+
 	// *** Internal resources
 
 	// Current render pass
@@ -2344,7 +2574,7 @@ private:
 	CIndexBuffer			_QuadIndexesAGP;
 
 	// The last setuped shader
-	CShader					*_CurrentShader;
+	CD3DShaderFX					*_CurrentShader;
 	UINT					_CurrentShaderPassCount;
 public:
 	struct CTextureRef
@@ -2369,29 +2599,29 @@ private:
 	CRenderVariable			*_ModifiedRenderState;
 
 	// Internal shaders
-	CShader					_ShaderLightmap0;
+	CD3DShaderFX					_ShaderLightmap0;
-	CShader					_ShaderLightmap1;
+	CD3DShaderFX					_ShaderLightmap1;
-	CShader					_ShaderLightmap2;
+	CD3DShaderFX					_ShaderLightmap2;
-	CShader					_ShaderLightmap3;
+	CD3DShaderFX					_ShaderLightmap3;
-	CShader					_ShaderLightmap4;
+	CD3DShaderFX					_ShaderLightmap4;
-	CShader					_ShaderLightmap0Blend;
+	CD3DShaderFX					_ShaderLightmap0Blend;
-	CShader					_ShaderLightmap1Blend;
+	CD3DShaderFX					_ShaderLightmap1Blend;
-	CShader					_ShaderLightmap2Blend;
+	CD3DShaderFX					_ShaderLightmap2Blend;
-	CShader					_ShaderLightmap3Blend;
+	CD3DShaderFX					_ShaderLightmap3Blend;
-	CShader					_ShaderLightmap4Blend;
+	CD3DShaderFX					_ShaderLightmap4Blend;
-	CShader					_ShaderLightmap0X2;
+	CD3DShaderFX					_ShaderLightmap0X2;
-	CShader					_ShaderLightmap1X2;
+	CD3DShaderFX					_ShaderLightmap1X2;
-	CShader					_ShaderLightmap2X2;
+	CD3DShaderFX					_ShaderLightmap2X2;
-	CShader					_ShaderLightmap3X2;
+	CD3DShaderFX					_ShaderLightmap3X2;
-	CShader					_ShaderLightmap4X2;
+	CD3DShaderFX					_ShaderLightmap4X2;
-	CShader					_ShaderLightmap0BlendX2;
+	CD3DShaderFX					_ShaderLightmap0BlendX2;
-	CShader					_ShaderLightmap1BlendX2;
+	CD3DShaderFX					_ShaderLightmap1BlendX2;
-	CShader					_ShaderLightmap2BlendX2;
+	CD3DShaderFX					_ShaderLightmap2BlendX2;
-	CShader					_ShaderLightmap3BlendX2;
+	CD3DShaderFX					_ShaderLightmap3BlendX2;
-	CShader					_ShaderLightmap4BlendX2;
+	CD3DShaderFX					_ShaderLightmap4BlendX2;
-	CShader					_ShaderCloud;
+	CD3DShaderFX					_ShaderCloud;
-	CShader					_ShaderWaterNoDiffuse;
+	CD3DShaderFX					_ShaderWaterNoDiffuse;
-	CShader					_ShaderWaterDiffuse;
+	CD3DShaderFX					_ShaderWaterDiffuse;
 
 
 	// Backup frame buffer
@@ -2527,6 +2757,10 @@ public:
 	// Clip the wanted rectangle with window. return true if rect is not NULL.
 	bool					clipRect(NLMISC::CRect &rect);
 
+	friend	class	IShaderDrvInfos;
+
+	void			removeShaderDrvInfoPtr(ItShaderDrvInfoPtrList shaderIt);
+
 };
 
 #define NL_D3DCOLOR_RGBA(rgba) (D3DCOLOR_ARGB(rgba.A,rgba.R,rgba.G,rgba.B))

code/nel/src/3d/driver/direct3d/driver_direct3d_material.cpp

@@ -328,7 +328,7 @@ bool CDriverD3D::setupMaterial(CMaterial &mat)
 	pShader = static_cast<CMaterialDrvInfosD3D*>((IMaterialDrvInfos*)(mat._MatDrvInfo));
 
 	// Now we can get the supported shader from the cache.
-	CMaterial::TShader matShader = mat.getShader();
+	CMaterial::TShader matShader = _PixelProgramUser ? CMaterial::Program : mat.getShader();
 
 	if (_CurrentMaterialSupportedShader != CMaterial::Normal)
 	{
@@ -567,7 +567,7 @@ bool CDriverD3D::setupMaterial(CMaterial &mat)
 								normalShaderDesc.TexEnvMode[stage] = mat.getTexEnvMode(uint8(stage));
 							}
 
-							if (_PixelShader)
+							if (_PixelProgram)
 							{
 								#ifdef NL_DEBUG_D3D
 									// Check, should not occured
@@ -648,7 +648,9 @@ bool CDriverD3D::setupMaterial(CMaterial &mat)
 		// Must separate texture setup and texture activation in 2 "for"...
 		// because setupTexture() may disable all stage.
 
-		if (matShader == CMaterial::Normal)
+		if (matShader == CMaterial::Normal 
+			|| ((matShader == CMaterial::Program) && (_PixelProgramUser->features().MaterialFlags & CProgramFeatures::TextureStages))
+			)
 		{
 			uint stage;
 			for(stage=0 ; stage<maxTexture; ++stage)
@@ -668,7 +670,9 @@ bool CDriverD3D::setupMaterial(CMaterial &mat)
 	// Don't do it also for Specular because the EnvFunction and the TexGen may be special.
 	{
 		H_AUTO_D3D(CDriverD3D_setupMaterial_normalShaderActivateTextures)
-		if(matShader == CMaterial::Normal)
+		if (matShader == CMaterial::Normal 
+			|| ((matShader == CMaterial::Program) && (_PixelProgramUser->features().MaterialFlags & CProgramFeatures::TextureStages))
+			)
 		{
 			uint stage;
 			for(stage=0 ; stage<maxTexture; ++stage)
@@ -933,7 +937,7 @@ bool CDriverD3D::setupMaterial(CMaterial &mat)
 				activeShader (NULL);
 
 				/* If unlighted trick is needed, set the shader later */
-				if (!pShader->NeedsConstantForDiffuse && _PixelShader)
+				if (!pShader->NeedsConstantForDiffuse && _PixelProgram)
 					setPixelShader (pShader->PixelShader);
 			}
 			break;
@@ -2019,7 +2023,7 @@ void CDriverD3D::endMaterialMultiPass()
 bool CDriverD3D::supportCloudRenderSinglePass () const
 {
 	H_AUTO_D3D(CDriver3D_supportCloudRenderSinglePass);
-	return _PixelShader;
+	return _PixelProgram;
 }
 
 // ***************************************************************************

code/nel/src/3d/driver/direct3d/driver_direct3d_pixel_program.cpp

@@ -0,0 +1,153 @@
+/** \file driver_direct3d_pixel_program.cpp
+ * Direct 3d driver implementation
+ *
+ * $Id: driver_direct3d_pixel_program.cpp,v 1.1.2.4 2007/07/09 15:26:35 legallo Exp $
+ *
+ * \todo manage better the init/release system (if a throw occurs in the init, we must release correctly the driver)
+ */
+
+/* Copyright, 2000 Nevrax Ltd.
+ *
+ * This file is part of NEVRAX NEL.
+ * NEVRAX NEL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+
+ * NEVRAX NEL is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with NEVRAX NEL; see the file COPYING. If not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ */
+
+#include "stddirect3d.h"
+
+#include "driver_direct3d.h"
+
+using namespace std;
+using namespace NLMISC;
+
+namespace NL3D 
+{
+
+// ***************************************************************************
+
+CPixelProgramDrvInfosD3D::CPixelProgramDrvInfosD3D(IDriver *drv, ItGPUPrgDrvInfoPtrList it) : IProgramDrvInfos (drv, it)
+{
+	H_AUTO_D3D(CPixelProgramDrvInfosD3D_CPixelProgamDrvInfosD3D)
+	Shader = NULL;
+}
+
+// ***************************************************************************
+
+CPixelProgramDrvInfosD3D::~CPixelProgramDrvInfosD3D()
+{
+	H_AUTO_D3D(CPixelProgramDrvInfosD3D_CPixelProgramDrvInfosD3DDtor)
+	if (Shader)
+		Shader->Release();
+}
+
+// ***************************************************************************
+
+bool CDriverD3D::supportPixelProgram (CPixelProgram::TProfile profile) const
+{
+	H_AUTO_D3D(CDriverD3D_supportPixelProgram_profile)
+	return ((profile & 0xFFFF0000) == 0xD9020000)
+		&& (_PixelProgramVersion >= (uint16)(profile & 0x0000FFFF));
+}
+
+// ***************************************************************************
+
+bool CDriverD3D::compilePixelProgram(CPixelProgram *program)
+{
+	// Program setuped ?
+	if (program->m_DrvInfo==NULL)
+	{
+		// Find a supported pixel program profile
+		IProgram::CSource *source = NULL;
+		for (uint i = 0; i < program->getSourceNb(); ++i)
+		{
+			if (supportPixelProgram(program->getSource(i)->Profile))
+			{
+				source = program->getSource(i);
+			}
+		}
+		if (!source)
+		{
+			nlwarning("No supported source profile for pixel program");
+			return false;
+		}
+
+		_GPUPrgDrvInfos.push_front (NULL);
+		ItGPUPrgDrvInfoPtrList itPix = _GPUPrgDrvInfos.begin();
+		CPixelProgramDrvInfosD3D *drvInfo;
+		*itPix = drvInfo = new CPixelProgramDrvInfosD3D(this, itPix);
+
+		// Create a driver info structure
+		program->m_DrvInfo = *itPix;
+
+		LPD3DXBUFFER pShader;
+		LPD3DXBUFFER pErrorMsgs;
+		if (D3DXAssembleShader(source->SourcePtr, source->SourceLen, NULL, NULL, 0, &pShader, &pErrorMsgs) == D3D_OK)
+		{
+			if (_DeviceInterface->CreatePixelShader((DWORD*)pShader->GetBufferPointer(), &(getPixelProgramD3D(*program)->Shader)) != D3D_OK)
+				return false;
+		}
+		else
+		{
+			nlwarning ("Can't assemble pixel program:");
+			nlwarning ((const char*)pErrorMsgs->GetBufferPointer());
+			return false;
+		}
+
+		// Set parameters for assembly programs
+		drvInfo->ParamIndices = source->ParamIndices;
+
+		// Build the feature info
+		program->buildInfo(source);
+	}
+
+	return true;
+}
+
+// ***************************************************************************
+
+bool CDriverD3D::activePixelProgram(CPixelProgram *program)
+{
+	H_AUTO_D3D(CDriverD3D_activePixelProgram )
+	if (_DisableHardwarePixelProgram)
+		return false;
+
+	// Set the pixel program
+	if (program)
+	{
+		if (!CDriverD3D::compilePixelProgram(program)) return false;
+
+		CPixelProgramDrvInfosD3D *info = static_cast<CPixelProgramDrvInfosD3D *>((IProgramDrvInfos*)program->m_DrvInfo);
+		_PixelProgramUser = program;
+		setPixelShader(info->Shader);
+	}
+	else
+	{
+		setPixelShader(NULL);
+		_PixelProgramUser = NULL;
+	}
+
+	return true;
+}
+
+// ***************************************************************************
+
+void CDriverD3D::disableHardwarePixelProgram()
+{
+	H_AUTO_D3D(CDriverD3D_disableHardwarePixelProgram)
+	_DisableHardwarePixelProgram = true;
+	_PixelProgram = false;
+}
+
+} // NL3D

code/nel/src/3d/driver/direct3d/driver_direct3d_shader.cpp

@@ -17,6 +17,8 @@
 #include "stddirect3d.h"
 
 #include "driver_direct3d.h"
+#include "nel/misc/path.h"
+#include "nel/misc/file.h"
 
 using namespace std;
 using namespace NLMISC;
@@ -24,6 +26,93 @@ using namespace NLMISC;
 namespace NL3D
 {
 
+
+// ***************************************************************************
+
+CD3DShaderFX::~CD3DShaderFX()
+{
+	// Must kill the drv mirror of this shader.
+	_DrvInfo.kill();
+}
+
+// ***************************************************************************
+
+CD3DShaderFX::CD3DShaderFX()
+{
+	_ShaderChanged = true;
+}
+
+// ***************************************************************************
+
+void CD3DShaderFX::setText (const char *text)
+{
+	_Text = text;
+	_ShaderChanged = true;
+}
+
+// ***************************************************************************
+
+void CD3DShaderFX::setName (const char *name)
+{
+	_Name = name;
+	_ShaderChanged = true;
+}
+
+// ***************************************************************************
+
+bool CD3DShaderFX::loadShaderFile (const char *filename)
+{
+	_Text = "";
+	// Lookup
+	string _filename = NLMISC::CPath::lookup(filename, false, true, true);
+	if (!_filename.empty())
+	{
+		// File length
+		uint size = NLMISC::CFile::getFileSize (_filename);
+		_Text.reserve (size+1);
+
+		try
+		{
+			NLMISC::CIFile file;
+			if (file.open (_filename))
+			{
+				// Read it
+				while (!file.eof ())
+				{
+					char line[512];
+					file.getline (line, 512);
+					_Text += line;
+				}
+
+				// Set the shader name
+				_Name = NLMISC::CFile::getFilename (filename);
+				return true;
+			}
+			else
+			{
+				nlwarning ("Can't open the file %s for reading", _filename.c_str());
+			}
+		}
+		catch (const Exception &e)
+		{
+			nlwarning ("Error while reading %s : %s", _filename.c_str(), e.what());
+		}
+	}
+	return false;
+}
+
+// ***************************************************************************
+
+IShaderDrvInfos::~IShaderDrvInfos()
+{
+	_Driver->removeShaderDrvInfoPtr(_DriverIterator);
+}
+
+void CDriverD3D::removeShaderDrvInfoPtr(ItShaderDrvInfoPtrList shaderIt)
+{
+	_ShaderDrvInfos.erase(shaderIt);
+}
+
 // mem allocator for state records
 std::allocator<uint8> CStateRecord::Allocator;
 
@@ -249,7 +338,7 @@ HRESULT CDriverD3D::SetVertexShaderConstantI(UINT StartRegister, CONST INT* pCon
 
 // ***************************************************************************
 
-CShaderDrvInfosD3D::CShaderDrvInfosD3D(IDriver *drv, ItShaderDrvInfoPtrList it) : IShaderDrvInfos(drv, it)
+CShaderDrvInfosD3D::CShaderDrvInfosD3D(CDriverD3D *drv, ItShaderDrvInfoPtrList it) : IShaderDrvInfos(drv, it)
 {
 	H_AUTO_D3D(CShaderDrvInfosD3D_CShaderDrvInfosD3D)
 	Validated = false;
@@ -265,7 +354,7 @@ CShaderDrvInfosD3D::~CShaderDrvInfosD3D()
 
 // ***************************************************************************
 
-bool CDriverD3D::validateShader(CShader *shader)
+bool CDriverD3D::validateShader(CD3DShaderFX *shader)
 {
 	H_AUTO_D3D(CDriverD3D_validateShader)
 	CShaderDrvInfosD3D *shaderInfo = static_cast<CShaderDrvInfosD3D*>((IShaderDrvInfos*)shader->_DrvInfo);
@@ -327,7 +416,7 @@ bool CDriverD3D::validateShader(CShader *shader)
 
 // ***************************************************************************
 
-bool CDriverD3D::activeShader(CShader *shd)
+bool CDriverD3D::activeShader(CD3DShaderFX *shd)
 {
 	H_AUTO_D3D(CDriverD3D_activeShader)
 	if (_DisableHardwarePixelShader)
@@ -393,7 +482,7 @@ bool CDriverD3D::activeShader(CShader *shd)
 }
 
 
-static void setFX(CShader &s, const char *name, const char *prog, CDriverD3D *drv)
+static void setFX(CD3DShaderFX &s, const char *name, const char *prog, CDriverD3D *drv)
 {
 	H_AUTO_D3D(setFX)
 

code/nel/src/3d/driver/direct3d/driver_direct3d_texture.cpp

@@ -1187,6 +1187,11 @@ bool CDriverD3D::setRenderTarget (ITexture *tex, uint32 /* x */, uint32 /* y */,
 	return true;
 }
 
+ITexture *CDriverD3D::getRenderTarget() const
+{
+	return _RenderTarget.Texture;
+}
+
 // ***************************************************************************
 
 bool CDriverD3D::copyTargetToTexture (ITexture * /* tex */, uint32 /* offsetx */, uint32 /* offsety */, uint32 /* x */, uint32 /* y */, uint32 /* width */,

code/nel/src/3d/driver/direct3d/driver_direct3d_uniform.cpp

@@ -0,0 +1,242 @@
+// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
+// Copyright (C) 2010  Winch Gate Property Limited
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "stddirect3d.h"
+
+#include "driver_direct3d.h"
+
+using namespace std;
+using namespace NLMISC;
+
+namespace NL3D
+{
+
+void CDriverD3D::setUniform4f(TProgram program, uint index, float f0, float f1, float f2, float f3)
+{
+	H_AUTO_D3D(CDriverD3D_setUniform4f);
+
+	const float tabl[4] = { f0, f1, f2, f3 };
+	switch (program)
+	{
+	case VertexProgram:
+		if (_VertexProgram)
+		{
+			setVertexProgramConstant(index, tabl);
+		}
+		break;
+	case PixelProgram:
+		if (_PixelProgram)
+		{
+			setPixelShaderConstant(index, tabl);
+		}
+		break;
+	}
+}
+
+void CDriverD3D::setUniform4fv(TProgram program, uint index, size_t num, const float *src)
+{
+	H_AUTO_D3D(CDriverD3D_setUniform4fv);
+
+	switch (program)
+	{
+	case VertexProgram:
+		if (_VertexProgram)
+		{
+			for (uint i = 0; i < num; ++i)
+			{
+				setVertexProgramConstant(index + i, src + (i * 4));
+			}
+		}
+		break;
+	case PixelProgram:
+		if (_PixelProgram)
+		{
+			for (uint i = 0; i < num; ++i)
+			{
+				setPixelShaderConstant(index + i, src + (i * 4));
+			}
+		}
+		break;
+	}
+}
+
+void CDriverD3D::setUniform1f(TProgram program, uint index, float f0)
+{
+	CDriverD3D::setUniform4f(program, index, f0, 0.f, 0.f, 0.f);
+}
+
+void CDriverD3D::setUniform2f(TProgram program, uint index, float f0, float f1)
+{
+	CDriverD3D::setUniform4f(program, index, f0, f1, 0.f, 0.f);
+}
+
+void CDriverD3D::setUniform3f(TProgram program, uint index, float f0, float f1, float f2)
+{
+	CDriverD3D::setUniform4f(program, index, f0, f1, f2, 0.0f);
+}
+
+void CDriverD3D::setUniform1i(TProgram program, uint index, sint32 i0)
+{
+
+}
+
+void CDriverD3D::setUniform2i(TProgram program, uint index, sint32 i0, sint32 i1)
+{
+
+}
+
+void CDriverD3D::setUniform3i(TProgram program, uint index, sint32 i0, sint32 i1, sint32 i2)
+{
+
+}
+
+void CDriverD3D::setUniform4i(TProgram program, uint index, sint32 i0, sint32 i1, sint32 i2, sint32 i3)
+{
+
+}
+
+void CDriverD3D::setUniform1ui(TProgram program, uint index, uint32 ui0)
+{
+
+}
+
+void CDriverD3D::setUniform2ui(TProgram program, uint index, uint32 ui0, uint32 ui1)
+{
+
+}
+
+void CDriverD3D::setUniform3ui(TProgram program, uint index, uint32 ui0, uint32 ui1, uint32 ui2)
+{
+
+}
+
+void CDriverD3D::setUniform4ui(TProgram program, uint index, uint32 ui0, uint32 ui1, uint32 ui2, uint32 ui3)
+{
+
+}
+
+void CDriverD3D::setUniform3f(TProgram program, uint index, const NLMISC::CVector& v)
+{
+	CDriverD3D::setUniform4f(program, index, v.x, v.y, v.z, 0.f);
+}
+
+void CDriverD3D::setUniform4f(TProgram program, uint index, const NLMISC::CVector& v, float f3)
+{
+	CDriverD3D::setUniform4f(program, index, v.x, v.y, v.z, f3);
+}
+
+void CDriverD3D::setUniform4f(TProgram program, uint index, const NLMISC::CRGBAF& rgba)
+{
+	CDriverD3D::setUniform4fv(program, index, 1, &rgba.R);
+}
+
+void CDriverD3D::setUniform4x4f(TProgram program, uint index, const NLMISC::CMatrix& m)
+{
+	H_AUTO_D3D(CDriverD3D_setUniform4x4f);
+
+	// TODO: Verify this!
+	NLMISC::CMatrix mat = m;
+	mat.transpose();
+	const float *md = mat.get();
+
+	CDriverD3D::setUniform4fv(program, index, 4, md);
+}
+
+void CDriverD3D::setUniform4iv(TProgram program, uint index, size_t num, const sint32 *src)
+{
+	
+}
+
+void CDriverD3D::setUniform4uiv(TProgram program, uint index, size_t num, const uint32 *src)
+{
+	
+}
+
+void CDriverD3D::setUniformMatrix(NL3D::IDriver::TProgram program, uint index, NL3D::IDriver::TMatrix matrix, NL3D::IDriver::TTransform transform)
+{
+	H_AUTO_D3D(CDriverD3D_setUniformMatrix);
+	
+	D3DXMATRIX mat;
+	D3DXMATRIX *matPtr = NULL;
+	switch (matrix)
+	{
+		case IDriver::ModelView:
+			matPtr = &_D3DModelView;
+		break;
+		case IDriver::Projection:
+			matPtr = &(_MatrixCache[remapMatrixIndex(D3DTS_PROJECTION)].Matrix);
+		break;
+		case IDriver::ModelViewProjection:
+			matPtr = &_D3DModelViewProjection;
+		break;
+	}
+	if (transform != IDriver::Identity)
+	{
+		switch (transform)
+		{
+			case IDriver::Inverse:
+				D3DXMatrixInverse(&mat, NULL, matPtr);
+			break;
+			case IDriver::Transpose:
+				D3DXMatrixTranspose(&mat, matPtr);
+			break;
+			case IDriver::InverseTranspose:
+				D3DXMatrixInverse(&mat, NULL, matPtr);
+				D3DXMatrixTranspose(&mat, &mat);
+			break;
+		}
+		matPtr = &mat;
+	}
+
+	D3DXMatrixTranspose(&mat, matPtr);
+	
+	CDriverD3D::setUniform4fv(program, index, 4, &mat.m[0][0]);
+}
+
+void CDriverD3D::setUniformFog(NL3D::IDriver::TProgram program, uint index)
+{
+	H_AUTO_D3D(CDriverD3D_setUniformFog)
+
+	/* "oFog" must always be between [1, 0] what ever you set in D3DRS_FOGSTART and D3DRS_FOGEND (1 for no fog, 0 for full fog).
+	The Geforce4 TI 4200 (drivers 53.03 and 45.23) doesn't accept other values for "oFog". */
+	const float delta = _FogEnd - _FogStart;
+	CDriverD3D::setUniform4f(program, index, 
+		-_D3DModelView._13 / delta, 
+		-_D3DModelView._23 / delta, 
+		-_D3DModelView._33 / delta, 
+		1 - (_D3DModelView._43 - _FogStart) / delta);
+}
+
+bool CDriverD3D::setUniformDriver(TProgram program)
+{
+	// todo
+
+	return true;
+}
+
+bool CDriverD3D::setUniformMaterial(TProgram program, CMaterial &material)
+{
+	// todo
+
+	return true;
+}
+
+void CDriverD3D::setUniformParams(TProgram program, CGPUProgramParams &params)
+{
+	// todo
+}
+
+} // NL3D

code/nel/src/3d/driver/direct3d/driver_direct3d_vertex_program.cpp

@@ -26,7 +26,7 @@ namespace NL3D
 
 // ***************************************************************************
 
-CVertexProgamDrvInfosD3D::CVertexProgamDrvInfosD3D(IDriver *drv, ItVtxPrgDrvInfoPtrList it) : IVertexProgramDrvInfos (drv, it)
+CVertexProgamDrvInfosD3D::CVertexProgamDrvInfosD3D(IDriver *drv, ItGPUPrgDrvInfoPtrList it) : IProgramDrvInfos (drv, it)
 {
 	H_AUTO_D3D(CVertexProgamDrvInfosD3D_CVertexProgamDrvInfosD3D)
 	Shader = NULL;
@@ -43,10 +43,10 @@ CVertexProgamDrvInfosD3D::~CVertexProgamDrvInfosD3D()
 
 // ***************************************************************************
 
-bool CDriverD3D::isVertexProgramSupported () const
+bool CDriverD3D::supportVertexProgram (CVertexProgram::TProfile profile) const
 {
-	H_AUTO_D3D(CDriverD3D_isVertexProgramSupported )
+	H_AUTO_D3D(CDriverD3D_supportVertexProgram )
-	return _VertexProgram;
+	return (profile == CVertexProgram::nelvp) && _VertexProgram;
 }
 
 // ***************************************************************************
@@ -262,24 +262,33 @@ void dump(const CVPParser::TProgram &prg, std::string &dest)
 
 // ***************************************************************************
 
-bool CDriverD3D::activeVertexProgram (CVertexProgram *program)
+bool CDriverD3D::compileVertexProgram(NL3D::CVertexProgram *program)
-{
-	H_AUTO_D3D(CDriverD3D_activeVertexProgram )
-	if (_DisableHardwareVertexProgram)
-		return false;
-
-	// Setup or unsetup ?
-	if (program)
 {
 	// Program setuped ?
-		if (program->_DrvInfo==NULL)
+	if (program->m_DrvInfo == NULL)
 	{
-			_VtxPrgDrvInfos.push_front (NULL);
+		// Find nelvp
-			ItVtxPrgDrvInfoPtrList itTex = _VtxPrgDrvInfos.begin();
+		IProgram::CSource *source = NULL;
-			*itTex = new CVertexProgamDrvInfosD3D(this, itTex);
+		for (uint i = 0; i < program->getSourceNb(); ++i)
+		{
+			if (program->getSource(i)->Profile == CVertexProgram::nelvp)
+			{
+				source = program->getSource(i);
+			}
+		}
+		if (!source)
+		{
+			nlwarning("Direct3D driver only supports 'nelvp' profile, vertex program cannot be used");
+			return false;
+		}
+
+		_GPUPrgDrvInfos.push_front (NULL);
+		ItGPUPrgDrvInfoPtrList itTex = _GPUPrgDrvInfos.begin();
+		CVertexProgamDrvInfosD3D *drvInfo;
+		*itTex = drvInfo = new CVertexProgamDrvInfosD3D(this, itTex);
 
 		// Create a driver info structure
-			program->_DrvInfo = *itTex;
+		program->m_DrvInfo = *itTex;
 
 		/** Check with our parser if the program will works with other implemented extensions, too. (EXT_vertex_shader ..).
 		  * There are some incompatibilities.
@@ -287,7 +296,7 @@ bool CDriverD3D::activeVertexProgram (CVertexProgram *program)
 		CVPParser parser;
 		CVPParser::TProgram parsedProgram;
 		std::string errorOutput;
-			bool result = parser.parse(program->getProgram().c_str(), parsedProgram, errorOutput);
+		bool result = parser.parse(source->SourcePtr, parsedProgram, errorOutput);
 		if (!result)
 		{
 			nlwarning("Unable to parse a vertex program :");
@@ -345,18 +354,38 @@ bool CDriverD3D::activeVertexProgram (CVertexProgram *program)
 			nlwarning ((const char*)pErrorMsgs->GetBufferPointer());
 			return false;
 		}
+
+		// Set parameters for assembly programs
+		drvInfo->ParamIndices = source->ParamIndices;
+
+		// Build the feature info
+		program->buildInfo(source);
 	}
+
+	return true;
 }
 
+// ***************************************************************************
+
+bool CDriverD3D::activeVertexProgram (CVertexProgram *program)
+{
+	H_AUTO_D3D(CDriverD3D_activeVertexProgram )
+	if (_DisableHardwareVertexProgram)
+		return false;
+
 	// Set the vertex program
 	if (program)
 	{
-		CVertexProgamDrvInfosD3D *info = static_cast<CVertexProgamDrvInfosD3D *>((IVertexProgramDrvInfos*)program->_DrvInfo);
+		if (!CDriverD3D::compileVertexProgram(program)) return false;
+
+		CVertexProgamDrvInfosD3D *info = NLMISC::safe_cast<CVertexProgamDrvInfosD3D *>((IProgramDrvInfos*)program->m_DrvInfo);
+		_VertexProgramUser = program;
 		setVertexProgram (info->Shader, program);
 
 		/* D3DRS_FOGSTART and D3DRS_FOGEND must be set with [1, 0] else the fog doesn't work properly on VertexShader and non-VertexShader objects
 		(random fog flicking) with Geforce4 TI 4200 (drivers 53.03 and 45.23). The other cards seam to interpret the "oFog"'s values using D3DRS_FOGSTART,
 		D3DRS_FOGEND.
+		Related to setUniformFog().
 		 */
 		float z = 0;
 		float o = 1;
@@ -366,6 +395,7 @@ bool CDriverD3D::activeVertexProgram (CVertexProgram *program)
 	else
 	{
 		setVertexProgram (NULL, NULL);
+		_VertexProgramUser = NULL;
 
 		// Set the old fog range
 		setRenderState (D3DRS_FOGSTART, *((DWORD*) (&_FogStart)));
@@ -377,171 +407,6 @@ bool CDriverD3D::activeVertexProgram (CVertexProgram *program)
 
 // ***************************************************************************
 
-void CDriverD3D::setConstant (uint index, float f0, float f1, float f2, float f3)
-{
-	H_AUTO_D3D(CDriverD3D_setConstant )
-	if (!_VertexProgram)
-	{
-		#ifdef NL_DEBUG
-			nlwarning("No vertex programs available!!");
-		#endif
-		return;
-	}
-	const float tabl[4] = {f0, f1, f2, f3};
-	setVertexProgramConstant (index, tabl);
-}
-
-// ***************************************************************************
-
-void CDriverD3D::setConstant (uint index, double d0, double d1, double d2, double d3)
-{
-	H_AUTO_D3D(CDriverD3D_setConstant )
-	if (!_VertexProgram)
-	{
-		#ifdef NL_DEBUG
-			nlwarning("No vertex programs available!!");
-		#endif
-		return;
-	}
-	const float tabl[4] = {(float)d0, (float)d1, (float)d2, (float)d3};
-	setVertexProgramConstant (index, tabl);
-}
-
-// ***************************************************************************
-
-void CDriverD3D::setConstant (uint index, const NLMISC::CVector& value)
-{
-	H_AUTO_D3D(CDriverD3D_setConstant )
-	if (!_VertexProgram)
-	{
-		#ifdef NL_DEBUG
-			nlwarning("No vertex programs available!!");
-		#endif
-		return;
-	}
-	const float tabl[4] = {value.x, value.y, value.z, 0};
-	setVertexProgramConstant (index, tabl);
-}
-
-// ***************************************************************************
-
-void CDriverD3D::setConstant (uint index, const NLMISC::CVectorD& value)
-{
-	H_AUTO_D3D(CDriverD3D_setConstant )
-	if (!_VertexProgram)
-	{
-		#ifdef NL_DEBUG
-			nlwarning("No vertex programs available!!");
-		#endif
-		return;
-	}
-	const float tabl[4] = {(float)value.x, (float)value.y, (float)value.z, 0};
-	setVertexProgramConstant (index, tabl);
-}
-
-// ***************************************************************************
-
-void CDriverD3D::setConstant (uint index, uint num, const float *src)
-{
-	H_AUTO_D3D(CDriverD3D_setConstant )
-	if (!_VertexProgram)
-	{
-		#ifdef NL_DEBUG
-			nlwarning("No vertex programs available!!");
-		#endif
-		return;
-	}
-	uint i;
-	for (i=0; i<num; i++)
-		setVertexProgramConstant (index+i, src+i*4);
-}
-
-// ***************************************************************************
-
-void CDriverD3D::setConstant (uint index, uint num, const double *src)
-{
-	H_AUTO_D3D(CDriverD3D_setConstant )
-	if (!_VertexProgram)
-	{
-		#ifdef NL_DEBUG
-			nlwarning("No vertex programs available!!");
-		#endif
-		return;
-	}
-	uint i;
-	for (i=0; i<num; i++)
-	{
-		const float tabl[4] = {(float)src[0], (float)src[1], (float)src[2], (float)src[3]};
-		setVertexProgramConstant (index+i, tabl);
-		src += 4;
-	}
-}
-
-// ***************************************************************************
-
-void CDriverD3D::setConstantMatrix (uint index, IDriver::TMatrix matrix, IDriver::TTransform transform)
-{
-	H_AUTO_D3D(CDriverD3D_setConstantMatrix )
-	if (!_VertexProgram)
-	{
-		#ifdef NL_DEBUG
-			nlwarning("No vertex programs available!!");
-		#endif
-		return;
-	}
-	D3DXMATRIX mat;
-	D3DXMATRIX *matPtr = NULL;
-	switch (matrix)
-	{
-		case IDriver::ModelView:
-			matPtr = &_D3DModelView;
-		break;
-		case IDriver::Projection:
-			matPtr = &(_MatrixCache[remapMatrixIndex (D3DTS_PROJECTION)].Matrix);
-		break;
-		case IDriver::ModelViewProjection:
-			matPtr = &_D3DModelViewProjection;
-		break;
-	}
-
-	if (transform != IDriver::Identity)
-	{
-		mat = *matPtr;
-		matPtr = &mat;
-		switch(transform)
-		{
-			case IDriver::Inverse:
-				D3DXMatrixInverse (&mat, NULL, &mat);
-			break;
-			case IDriver::Transpose:
-				D3DXMatrixTranspose (&mat, &mat);
-			break;
-			case IDriver::InverseTranspose:
-				D3DXMatrixInverse (&mat, NULL, &mat);
-				D3DXMatrixTranspose (&mat, &mat);
-			break;
-		}
-	}
-
-	setConstant (index, matPtr->_11, matPtr->_21, matPtr->_31, matPtr->_41);
-	setConstant (index+1, matPtr->_12, matPtr->_22, matPtr->_32, matPtr->_42);
-	setConstant (index+2, matPtr->_13, matPtr->_23, matPtr->_33, matPtr->_43);
-	setConstant (index+3, matPtr->_14, matPtr->_24, matPtr->_34, matPtr->_44);
-}
-
-// ***************************************************************************
-
-void CDriverD3D::setConstantFog (uint index)
-{
-	H_AUTO_D3D(CDriverD3D_setConstantFog )
-	/* "oFog" must always be between [1, 0] what ever you set in D3DRS_FOGSTART and D3DRS_FOGEND (1 for no fog, 0 for full fog).
-	The Geforce4 TI 4200 (drivers 53.03 and 45.23) doesn't accept other values for "oFog". */
-	const float delta = _FogEnd-_FogStart;
-	setConstant (index, - _D3DModelView._13/delta, -_D3DModelView._23/delta, -_D3DModelView._33/delta, 1-(_D3DModelView._43-_FogStart)/delta);
-}
-
-// ***************************************************************************
-
 void CDriverD3D::enableVertexProgramDoubleSidedColor(bool /* doubleSided */)
 {
 	H_AUTO_D3D(CDriverD3D_enableVertexProgramDoubleSidedColor)

code/nel/src/3d/driver/opengl/driver_opengl.cpp

@@ -263,8 +263,6 @@ CDriverGL::CDriverGL()
 	_CurrentFogColor[2]= 0;
 	_CurrentFogColor[3]= 0;
 
-	_RenderTargetFBO = false;
-
 	_LightSetupDirty= false;
 	_ModelViewMatrixDirty= false;
 	_RenderSetupDirty= false;
@@ -482,6 +480,7 @@ bool CDriverGL::setupDisplay()
 	}
 
 	_VertexProgramEnabled= false;
+	_PixelProgramEnabled= false;
 	_LastSetupGLArrayVertexProgram= false;
 
 	// Init VertexArrayRange according to supported extenstion.
@@ -690,7 +689,7 @@ bool CDriverGL::stretchRect(ITexture * /* srcText */, NLMISC::CRect &/* srcRect
 // ***************************************************************************
 bool CDriverGL::supportBloomEffect() const
 {
-	return (isVertexProgramSupported() && supportFrameBufferObject() && supportPackedDepthStencil() && supportTextureRectangle());
+	return (supportVertexProgram(CVertexProgram::nelvp) && supportFrameBufferObject() && supportPackedDepthStencil() && supportTextureRectangle());
 }
 
 // ***************************************************************************
@@ -702,7 +701,7 @@ bool CDriverGL::supportNonPowerOfTwoTextures() const
 // ***************************************************************************
 bool CDriverGL::isTextureRectangle(ITexture * tex) const
 {
-	return (supportTextureRectangle() && tex->isBloomTexture() && tex->mipMapOff()
+	return (!supportNonPowerOfTwoTextures() && supportTextureRectangle() && tex->isBloomTexture() && tex->mipMapOff()
 			&& (!isPowerOf2(tex->getWidth()) || !isPowerOf2(tex->getHeight())));
 }
 
@@ -737,6 +736,12 @@ void CDriverGL::disableHardwareVertexProgram()
 	_Extensions.DisableHardwareVertexProgram= true;
 }
 
+void CDriverGL::disableHardwarePixelProgram()
+{
+	H_AUTO_OGL(CDriverGL_disableHardwarePixelProgram)
+	_Extensions.DisableHardwarePixelProgram= true;
+}
+
 // ***************************************************************************
 void CDriverGL::disableHardwareVertexArrayAGP()
 {
@@ -854,6 +859,7 @@ bool CDriverGL::swapBuffers()
 	// Reset texture shaders
 	//resetTextureShaders();
 	activeVertexProgram(NULL);
+	activePixelProgram(NULL);
 
 #ifndef USE_OPENGLES
 	/* Yoyo: must do this (GeForce bug ??) else weird results if end render with a VBHard.
@@ -1400,6 +1406,7 @@ void CDriverGL::setupFog(float start, float end, CRGBA color)
 
 	glFogfv(GL_FOG_COLOR, _CurrentFogColor);
 
+#ifndef USE_OPENGLES
 	/** Special : with vertex program, using the extension EXT_vertex_shader, fog is emulated using 1 more constant to scale result to [0, 1]
 	  */
 	if (_Extensions.EXTVertexShader && !_Extensions.NVVertexProgram && !_Extensions.ARBVertexProgram)
@@ -1409,14 +1416,18 @@ void CDriverGL::setupFog(float start, float end, CRGBA color)
 			// last constant is used to store fog information (fog must be rescaled to [0, 1], because of a driver bug)
 			if (start != end)
 			{
-				setConstant(_EVSNumConstant, 1.f / (start - end), - end / (start - end), 0, 0);
+				float datas[] = { 1.f / (start - end), - end / (start - end), 0, 0 };
+				nglSetInvariantEXT(_EVSConstantHandle + _EVSNumConstant, GL_FLOAT, datas);
 			}
 			else
 			{
-				setConstant(_EVSNumConstant, 0.f, 0, 0, 0);
+				float datas[] = { 0.f, 0, 0, 0 };
+				nglSetInvariantEXT(_EVSConstantHandle + _EVSNumConstant, GL_FLOAT, datas);
 			}
 		}
 	}
+#endif
+
 	_FogStart = start;
 	_FogEnd = end;
 }
@@ -1535,9 +1546,9 @@ bool CDriverGL::supportTextureShaders() const
 }
 
 // ***************************************************************************
-bool CDriverGL::isWaterShaderSupported() const
+bool CDriverGL::supportWaterShader() const
 {
-	H_AUTO_OGL(CDriverGL_isWaterShaderSupported);
+	H_AUTO_OGL(CDriverGL_supportWaterShader);
 
 	if(_Extensions.ARBFragmentProgram && ARBWaterShader[0] != 0) return true;
 
@@ -1547,9 +1558,9 @@ bool CDriverGL::isWaterShaderSupported() const
 }
 
 // ***************************************************************************
-bool CDriverGL::isTextureAddrModeSupported(CMaterial::TTexAddressingMode /* mode */) const
+bool CDriverGL::supportTextureAddrMode(CMaterial::TTexAddressingMode /* mode */) const
 {
-	H_AUTO_OGL(CDriverGL_isTextureAddrModeSupported)
+	H_AUTO_OGL(CDriverGL_supportTextureAddrMode)
 
 	if (_Extensions.NVTextureShader)
 	{
@@ -1987,12 +1998,6 @@ static void fetchPerturbedEnvMapR200()
 #endif
 }
 
-// ***************************************************************************
-void CDriverGL::forceNativeFragmentPrograms(bool nativeOnly)
-{
-	_ForceNativeFragmentPrograms = nativeOnly;
-}
-
 // ***************************************************************************
 void CDriverGL::initFragmentShaders()
 {
@@ -2567,14 +2572,6 @@ CVertexBuffer::TVertexColorType CDriverGL::getVertexColorFormat() const
 	return CVertexBuffer::TRGBA;
 }
 
-// ***************************************************************************
-bool CDriverGL::activeShader(CShader * /* shd */)
-{
-	H_AUTO_OGL(CDriverGL_activeShader)
-
-	return false;
-}
-
 // ***************************************************************************
 void CDriverGL::startBench (bool wantStandardDeviation, bool quick, bool reset)
 {

code/nel/src/3d/driver/opengl/driver_opengl.h

@@ -49,7 +49,6 @@
 
 #include "nel/3d/driver.h"
 #include "nel/3d/material.h"
-#include "nel/3d/shader.h"
 #include "nel/3d/vertex_buffer.h"
 #include "nel/3d/ptr_set.h"
 #include "nel/3d/texture_cube.h"
@@ -308,6 +307,7 @@ public:
 	virtual bool			init (uint windowIcon = 0, emptyProc exitFunc = 0);
 
 	virtual void			disableHardwareVertexProgram();
+	virtual void			disableHardwarePixelProgram();
 	virtual void			disableHardwareVertexArrayAGP();
 	virtual void			disableHardwareTextureShader();
 
@@ -370,8 +370,6 @@ public:
 
 	virtual void			forceTextureResize(uint divisor);
 
-	virtual void			forceNativeFragmentPrograms(bool nativeOnly);
-
 	/// Setup texture env functions. Used by setupMaterial
 	void					setTextureEnvFunction(uint stage, CMaterial& mat);
 
@@ -405,8 +403,6 @@ public:
 
 	virtual CMatrix			getViewMatrix() const;
 
-	virtual bool			activeShader(CShader *shd);
-
 	virtual	void			forceNormalize(bool normalize)
 	{
 		_ForceNormalize= normalize;
@@ -565,6 +561,8 @@ public:
 	virtual bool			setRenderTarget (ITexture *tex, uint32 x, uint32 y, uint32 width, uint32 height,
 												uint32 mipmapLevel, uint32 cubeFace);
 
+	virtual ITexture		*getRenderTarget() const;
+
 	virtual bool			copyTargetToTexture (ITexture *tex, uint32 offsetx, uint32 offsety, uint32 x, uint32 y,
 													uint32 width, uint32 height, uint32 mipmapLevel);
 
@@ -602,9 +600,9 @@ public:
 	// @{
 	virtual bool			supportTextureShaders() const;
 
-	virtual bool			isWaterShaderSupported() const;
+	virtual bool			supportWaterShader() const;
 
-	virtual bool			isTextureAddrModeSupported(CMaterial::TTexAddressingMode mode) const;
+	virtual bool			supportTextureAddrMode(CMaterial::TTexAddressingMode mode) const;
 
 	virtual void			setMatrix2DForTextureOffsetAddrMode(const uint stage, const float mat[4]);
 	// @}
@@ -694,6 +692,7 @@ private:
 	virtual class IVertexBufferHardGL	*createVertexBufferHard(uint size, uint numVertices, CVertexBuffer::TPreferredMemory vbType, CVertexBuffer *vb);
 	friend class					CTextureDrvInfosGL;
 	friend class					CVertexProgamDrvInfosGL;
+	friend class					CPixelProgamDrvInfosGL;
 
 private:
 	// Version of the driver. Not the interface version!! Increment when implementation of the driver change.
@@ -889,7 +888,7 @@ private:
 	// viewport before call to setRenderTarget, if BFO extension is supported
 	CViewport				_OldViewport;
 
-	bool					_RenderTargetFBO;
+	CSmartPtr<ITexture>		_RenderTargetFBO;
 
 
 	// Num lights return by GL_MAX_LIGHTS
@@ -1300,36 +1299,156 @@ private:
 
 	// @}
 
-	/// \name Vertex program interface
+
+
+
+
+	/// \name Vertex Program
 	// @{
 
-	bool			isVertexProgramSupported () const;
+	// Order of preference
-	bool			isVertexProgramEmulated () const;
+	// - activeVertexProgram
-	bool			activeVertexProgram (CVertexProgram *program);
+	// - CMaterial pass[n] VP (uses activeVertexProgram, but does not override if one already set by code)
-	void			setConstant (uint index, float, float, float, float);
+	// - default generic VP that mimics fixed pipeline / no VP with fixed pipeline
-	void			setConstant (uint index, double, double, double, double);
+
-	void			setConstant (uint indexStart, const NLMISC::CVector& value);
+	/**
-	void			setConstant (uint indexStart, const NLMISC::CVectorD& value);
+	  * Does the driver supports vertex program, but emulated by CPU ?
-	void			setConstant (uint index, uint num, const float *src);
+	  */
-	void			setConstant (uint index, uint num, const double *src);
+	virtual bool			isVertexProgramEmulated() const;
-	void			setConstantMatrix (uint index, IDriver::TMatrix matrix, IDriver::TTransform transform);
+
-	void			setConstantFog (uint index);
+	/** Return true if the driver supports the specified vertex program profile.
-	void			enableVertexProgramDoubleSidedColor(bool doubleSided);
+	  */
-	bool		    supportVertexProgramDoubleSidedColor() const;
+	virtual bool			supportVertexProgram(CVertexProgram::TProfile profile) const;
+
+	/** Compile the given vertex program, return if successful.
+	  * If a vertex program was set active before compilation, 
+	  * the state of the active vertex program is undefined behaviour afterwards.
+	  */
+	virtual bool			compileVertexProgram(CVertexProgram *program);
+
+	/** Set the active vertex program. This will override vertex programs specified in CMaterial render calls.
+	  * Also used internally by setupMaterial(CMaterial) when getVertexProgram returns NULL.
+	  * The vertex program is activated immediately.
+	  */
+	virtual bool			activeVertexProgram(CVertexProgram *program);
+	// @}
+
+
+
+	/// \name Pixel Program
+	// @{
+
+	// Order of preference
+	// - activePixelProgram
+	// - CMaterial pass[n] PP (uses activePixelProgram, but does not override if one already set by code)
+	// - PP generated from CMaterial (uses activePixelProgram, but does not override if one already set by code)
+
+	/** Return true if the driver supports the specified pixel program profile.
+	  */
+	virtual bool			supportPixelProgram(CPixelProgram::TProfile profile = CPixelProgram::arbfp1) const;
+
+	/** Compile the given pixel program, return if successful.
+	  * If a pixel program was set active before compilation, 
+	  * the state of the active pixel program is undefined behaviour afterwards.
+	  */
+	virtual bool			compilePixelProgram(CPixelProgram *program);
+
+	/** Set the active pixel program. This will override pixel programs specified in CMaterial render calls.
+	  * Also used internally by setupMaterial(CMaterial) when getPixelProgram returns NULL.
+	  * The pixel program is activated immediately.
+	  */
+	virtual bool			activePixelProgram(CPixelProgram *program);
+	// @}
+
+
+
+	/// \name Geometry Program
+	// @{
+
+	// Order of preference
+	// - activeGeometryProgram
+	// - CMaterial pass[n] PP (uses activeGeometryProgram, but does not override if one already set by code)
+	// - none
+
+	/** Return true if the driver supports the specified pixel program profile.
+	  */
+	virtual bool			supportGeometryProgram(CGeometryProgram::TProfile profile) const { return false; }
+
+	/** Compile the given pixel program, return if successful.
+	  * If a pixel program was set active before compilation, 
+	  * the state of the active pixel program is undefined behaviour afterwards.
+	  */
+	virtual bool			compileGeometryProgram(CGeometryProgram *program) { return false; }
+
+	/** Set the active pixel program. This will override pixel programs specified in CMaterial render calls.
+	  * Also used internally by setupMaterial(CMaterial) when getGeometryProgram returns NULL.
+	  * The pixel program is activated immediately.
+	  */
+	virtual bool			activeGeometryProgram(CGeometryProgram *program) { return false; }
+	// @}
+
+
+
+	/// \name Program parameters
+	// @{
+	// Set parameters
+	inline void				setUniform4fInl(TProgram program, uint index, float f0, float f1, float f2, float f3);
+	inline void				setUniform4fvInl(TProgram program, uint index, size_t num, const float *src);
+	virtual void			setUniform1f(TProgram program, uint index, float f0);
+	virtual void			setUniform2f(TProgram program, uint index, float f0, float f1);
+	virtual void			setUniform3f(TProgram program, uint index, float f0, float f1, float f2);
+	virtual void			setUniform4f(TProgram program, uint index, float f0, float f1, float f2, float f3);
+	virtual void			setUniform1i(TProgram program, uint index, sint32 i0);
+	virtual void			setUniform2i(TProgram program, uint index, sint32 i0, sint32 i1);
+	virtual void			setUniform3i(TProgram program, uint index, sint32 i0, sint32 i1, sint32 i2);
+	virtual void			setUniform4i(TProgram program, uint index, sint32 i0, sint32 i1, sint32 i2, sint32 i3);
+	virtual void			setUniform1ui(TProgram program, uint index, uint32 ui0);
+	virtual void			setUniform2ui(TProgram program, uint index, uint32 ui0, uint32 ui1);
+	virtual void			setUniform3ui(TProgram program, uint index, uint32 ui0, uint32 ui1, uint32 ui2);
+	virtual void			setUniform4ui(TProgram program, uint index, uint32 ui0, uint32 ui1, uint32 ui2, uint32 ui3);
+	virtual void			setUniform3f(TProgram program, uint index, const NLMISC::CVector& v);
+	virtual void			setUniform4f(TProgram program, uint index, const NLMISC::CVector& v, float f3);
+	virtual void			setUniform4f(TProgram program, uint index, const NLMISC::CRGBAF& rgba);
+	virtual void			setUniform4x4f(TProgram program, uint index, const NLMISC::CMatrix& m);
+	virtual void			setUniform4fv(TProgram program, uint index, size_t num, const float *src);
+	virtual void			setUniform4iv(TProgram program, uint index, size_t num, const sint32 *src);
+	virtual void			setUniform4uiv(TProgram program, uint index, size_t num, const uint32 *src);
+	// Set builtin parameters
+	virtual void			setUniformMatrix(TProgram program, uint index, TMatrix matrix, TTransform transform);
+	virtual void			setUniformFog(TProgram program, uint index);
+    // Set feature parameters
+	virtual bool			isUniformProgramState() { return false; }
+	// @}
+
+
+
+
+
+	virtual void			enableVertexProgramDoubleSidedColor(bool doubleSided);
+	virtual bool		    supportVertexProgramDoubleSidedColor() const;
 
 	virtual	bool			supportMADOperator() const ;
 
 
-	// @}
 
 	/// \name Vertex program implementation
 	// @{
 		bool activeNVVertexProgram (CVertexProgram *program);
 		bool activeARBVertexProgram (CVertexProgram *program);
 		bool activeEXTVertexShader (CVertexProgram *program);
+
+		bool compileNVVertexProgram (CVertexProgram *program);
+		bool compileARBVertexProgram (CVertexProgram *program);
+		bool compileEXTVertexShader (CVertexProgram *program);
 	//@}
 
 
+	/// \name Pixel program implementation
+	// @{
+		bool activeARBPixelProgram (CPixelProgram *program);
+		bool setupPixelProgram (CPixelProgram *program, GLuint id/*, bool &specularWritten*/);
+	//@}
+ 
 
 	/// \fallback for material shaders
 	// @{
@@ -1343,14 +1462,26 @@ private:
 		return _VertexProgramEnabled;
 	}
  
+	bool			isPixelProgramEnabled () const
+	{
+		// Don't use glIsEnabled, too slow.
+		return _PixelProgramEnabled;
+	}
+
 	// Track state of activeVertexProgram()
 	bool							_VertexProgramEnabled;
+	// Track state of activePixelProgram()
+	bool							_PixelProgramEnabled;
+
 	// Say if last setupGlArrays() was a VertexProgram setup.
 	bool							_LastSetupGLArrayVertexProgram;
 
 	// The last vertex program that was setupped
 	NLMISC::CRefPtr<CVertexProgram> _LastSetuppedVP;
 
+	// The last pixel program that was setupped
+	NLMISC::CRefPtr<CPixelProgram> _LastSetuppedPP;
+
 	bool							_ForceDXTCCompression;
 	/// Divisor for textureResize (power).
 	uint							_ForceTextureResizePower;
@@ -1496,7 +1627,7 @@ private:
 };
 
 // ***************************************************************************
-class CVertexProgamDrvInfosGL : public IVertexProgramDrvInfos
+class CVertexProgamDrvInfosGL : public IProgramDrvInfos
 {
 public:
 	// The GL Id.
@@ -1517,7 +1648,36 @@ public:
 
 
 	// The gl id is auto created here.
-	CVertexProgamDrvInfosGL (CDriverGL *drv, ItVtxPrgDrvInfoPtrList it);
+	CVertexProgamDrvInfosGL (CDriverGL *drv, ItGPUPrgDrvInfoPtrList it);
+
+	virtual uint getUniformIndex(const char *name) const
+	{ 
+		std::map<std::string, uint>::const_iterator it = ParamIndices.find(name);
+		if (it != ParamIndices.end()) return it->second; 
+		return ~0;
+	};
+
+	std::map<std::string, uint> ParamIndices;
+};
+
+// ***************************************************************************
+class CPixelProgamDrvInfosGL : public IProgramDrvInfos
+{
+public:
+	// The GL Id.
+	GLuint					ID;
+ 
+	// The gl id is auto created here.
+	CPixelProgamDrvInfosGL (CDriverGL *drv, ItGPUPrgDrvInfoPtrList it);
+
+	virtual uint getUniformIndex(const char *name) const
+	{ 
+		std::map<std::string, uint>::const_iterator it = ParamIndices.find(name);
+		if (it != ParamIndices.end()) return it->second; 
+		return ~0;
+	};
+
+	std::map<std::string, uint> ParamIndices;
 };
 
 #ifdef NL_STATIC

code/nel/src/3d/driver/opengl/driver_opengl_extension.cpp

@@ -1225,6 +1225,15 @@ static bool	setupARBFragmentProgram(const char *glext)
 	return true;
 }
 
+// *********************************
+static bool	setupNVFragmentProgram2(const char *glext)
+{
+	H_AUTO_OGL(setupNVFragmentProgram2);
+	CHECK_EXT("GL_NV_fragment_program2");
+	
+	return true;
+}
+
 // ***************************************************************************
 static bool	setupARBVertexBufferObject(const char	*glext)
 {
@@ -1561,6 +1570,19 @@ void	registerGlExtensions(CGlExtensions &ext)
 		ext.ARBVertexProgram = false;
 	}
 	
+	// Check pixel program
+	// Disable feature ???
+	if (!ext.DisableHardwarePixelProgram)
+	{		
+		ext.ARBFragmentProgram = setupARBFragmentProgram(glext);	
+		ext.NVFragmentProgram2 = setupNVFragmentProgram2(glext);
+	}
+	else
+	{
+		ext.ARBFragmentProgram = false;
+		ext.NVFragmentProgram2 = false;
+	}
+
 	ext.OESDrawTexture = setupOESDrawTexture(glext);
 	ext.OESMapBuffer = setupOESMapBuffer(glext);
 
@@ -1571,14 +1593,12 @@ void	registerGlExtensions(CGlExtensions &ext)
 		ext.NVTextureShader = setupNVTextureShader(glext);
 		ext.ATIEnvMapBumpMap = setupATIEnvMapBumpMap(glext);
 		ext.ATIFragmentShader = setupATIFragmentShader(glext);
-		ext.ARBFragmentProgram = setupARBFragmentProgram(glext);
 	}
 	else
 	{
 		ext.ATIEnvMapBumpMap = false;
 		ext.NVTextureShader = false;
 		ext.ATIFragmentShader = false;
-		ext.ARBFragmentProgram = false;
 	}
 
 	// For now, the only way to know if emulation, is to test some extension which exist only on GeForce3.

code/nel/src/3d/driver/opengl/driver_opengl_extension.h

@@ -103,6 +103,9 @@ struct	CGlExtensions
 	bool	ARBTextureNonPowerOfTwo;
 	bool	ARBMultisample;
 
+	// NV Pixel Programs
+	bool	NVFragmentProgram2;
+
 	bool	OESDrawTexture;
 	bool	OESMapBuffer;
 
@@ -111,6 +114,7 @@ public:
 	/// \name Disable Hardware feature. False by default. setuped by IDriver
 	// @{
 	bool				DisableHardwareVertexProgram;
+	bool				DisableHardwarePixelProgram;
 	bool				DisableHardwareVertexArrayAGP;
 	bool				DisableHardwareTextureShader;
 	// @}
@@ -174,6 +178,7 @@ public:
 
 		/// \name Disable Hardware feature. False by default. setuped by IDriver
 		DisableHardwareVertexProgram= false;
+		DisableHardwarePixelProgram= false;
 		DisableHardwareVertexArrayAGP= false;
 		DisableHardwareTextureShader= false;
 	}
@@ -206,6 +211,7 @@ public:
 		result += NVTextureShader ? "NVTextureShader " : "";
 		result += ATIFragmentShader ? "ATIFragmentShader " : "";
 		result += ARBFragmentProgram ? "ARBFragmentProgram " : "";
+		result += NVFragmentProgram2 ? "NVFragmentProgram2 " : "";
 		result += ARBVertexProgram ? "ARBVertexProgram " : "";
 		result += NVVertexProgram ? "NVVertexProgram " : "";
 		result += EXTVertexShader ? "EXTVertexShader " : "";

code/nel/src/3d/driver/opengl/driver_opengl_material.cpp

@@ -283,14 +283,15 @@ void CDriverGL::setTextureShaders(const uint8 *addressingModes, const CSmartPtr<
 bool CDriverGL::setupMaterial(CMaterial& mat)
 {
 	H_AUTO_OGL(CDriverGL_setupMaterial)
-	CShaderGL*	pShader;
-	GLenum		glenum = GL_ZERO;
-	uint32		touched = mat.getTouched();
-	uint		stage;
 
 	// profile.
 	_NbSetupMaterialCall++;
 
+	CMaterial::TShader matShader;
+	
+	CShaderGL*	pShader;
+	GLenum		glenum = GL_ZERO;
+	uint32		touched = mat.getTouched();
 
 	// 0. Retrieve/Create driver shader.
 	//==================================
@@ -359,9 +360,29 @@ bool CDriverGL::setupMaterial(CMaterial& mat)
 		mat.clearTouched(0xFFFFFFFF);
 	}
 
-	// Now we can get the supported shader from the cache.
+	// 2b. User supplied pixel shader overrides material
-	CMaterial::TShader matShader = pShader->SupportedShader;
+	//==================================
+	/*if (_VertexProgramEnabled)
+	{
+		if (!setUniformDriver(VertexProgram)) return false;
+		if (!setUniformMaterialInternal(VertexProgram, mat)) return false;
+	}*/
+	if (_PixelProgramEnabled)
+	{
+		matShader = CMaterial::Program;
 
+		// if (!setUniformDriver(PixelProgram)) return false;
+		// if (!setUniformMaterialInternal(PixelProgram, mat)) return false;
+		if (!_LastSetuppedPP) return false;
+	}
+	else
+	{
+		// Now we can get the supported shader from the cache.
+		matShader = pShader->SupportedShader;
+	}
+
+	// 2b. Update more shader state
+	//==================================
 	// if the shader has changed since last time
 	if(matShader != _CurrentMaterialSupportedShader)
 	{
@@ -382,9 +403,11 @@ bool CDriverGL::setupMaterial(CMaterial& mat)
 	// Must setup textures each frame. (need to test if touched).
 	// Must separate texture setup and texture activation in 2 "for"...
 	// because setupTexture() may disable all stage.
-	if (matShader != CMaterial::Water)
+	if (matShader != CMaterial::Water 
+		&& ((matShader != CMaterial::Program) || (_LastSetuppedPP->features().MaterialFlags & CProgramFeatures::TextureStages))
+		)
 	{
-		for(stage=0 ; stage<inlGetNumTextStages() ; stage++)
+		for (uint stage = 0; stage < inlGetNumTextStages(); ++stage)
 		{
 			ITexture	*text= mat.getTexture(uint8(stage));
 			if (text != NULL && !setupTexture(*text))
@@ -394,7 +417,7 @@ bool CDriverGL::setupMaterial(CMaterial& mat)
 	// Here, for Lightmap materials, setup the lightmaps.
 	if(matShader == CMaterial::LightMap)
 	{
-		for(stage = 0; stage < mat._LightMaps.size(); stage++)
+		for (uint stage = 0; stage < mat._LightMaps.size(); ++stage)
 		{
 			ITexture *text = mat._LightMaps[stage].Texture;
 			if (text != NULL && !setupTexture(*text))
@@ -418,9 +441,10 @@ bool CDriverGL::setupMaterial(CMaterial& mat)
 		&& matShader != CMaterial::Cloud
 		&& matShader != CMaterial::Water
 		&& matShader != CMaterial::Specular
+		&& ((matShader != CMaterial::Program) || (_LastSetuppedPP->features().MaterialFlags & CProgramFeatures::TextureStages))
 	   )
 	{
-		for(stage=0 ; stage<inlGetNumTextStages() ; stage++)
+		for(uint stage=0 ; stage<inlGetNumTextStages() ; stage++)
 		{
 			ITexture	*text= mat.getTexture(uint8(stage));
 
@@ -548,11 +572,13 @@ bool CDriverGL::setupMaterial(CMaterial& mat)
 		resetLightMapVertexSetup();
 
 	// Textures user matrix
-	if (matShader == CMaterial::Normal)
+	if (matShader == CMaterial::Normal
+		|| ((matShader == CMaterial::Program) && (_LastSetuppedPP->features().MaterialFlags & CProgramFeatures::TextureMatrices))
+		)
 	{
 		setupUserTextureMatrix(inlGetNumTextStages(), mat);
 	}
-	else // deactivate texture matrix
+	else
 	{
 		disableUserTextureMatrix();
 	}
@@ -1476,7 +1502,7 @@ CTextureCube	*CDriverGL::getSpecularCubeMap(uint exp)
 	{
 		1.f, 4.f, 8.f, 24.f, 48.f, 128.f, 256.f, 511.f
 	};
-	const uint numCubeMap = sizeof(expToCubeMap) / sizeof(float);
+	const uint numCubeMap = sizeof(cubeMapExp) / sizeof(float);
 	static bool tableBuilt = false;
 
 	if (!tableBuilt)

code/nel/src/3d/driver/opengl/driver_opengl_pixel_program.cpp

@@ -0,0 +1,251 @@
+/** \file driver_opengl_pixel_program.cpp
+ * OpenGL driver implementation for pixel program manipulation.
+ *
+ * $Id: driver_opengl_pixel_program.cpp,v 1.1.2.4 2007/07/09 15:29:00 legallo Exp $
+ *
+ * \todo manage better the init/release system (if a throw occurs in the init, we must release correctly the driver)
+ */
+
+/* Copyright, 2000 Nevrax Ltd.
+ *
+ * This file is part of NEVRAX NEL.
+ * NEVRAX NEL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+
+ * NEVRAX NEL is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with NEVRAX NEL; see the file COPYING. If not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ */
+
+#include "stdopengl.h"
+
+#include "driver_opengl.h"
+#include "nel/3d/index_buffer.h"
+#include "nel/3d/pixel_program.h"
+#include <algorithm>
+
+// tmp
+#include "nel/misc/file.h"
+
+using namespace std;
+using namespace NLMISC;
+ 
+namespace NL3D
+{
+	
+#ifdef NL_STATIC
+#ifdef USE_OPENGLES
+namespace NLDRIVERGLES {
+#else
+namespace NLDRIVERGL {
+#endif
+#endif
+
+// ***************************************************************************
+
+CPixelProgamDrvInfosGL::CPixelProgamDrvInfosGL (CDriverGL *drv, ItGPUPrgDrvInfoPtrList it) : IProgramDrvInfos (drv, it) 
+{
+	H_AUTO_OGL(CPixelProgamDrvInfosGL_CPixelProgamDrvInfosGL)
+
+#ifndef USE_OPENGLES
+	// Extension must exist
+	nlassert(drv->_Extensions.ARBFragmentProgram);
+
+	if (drv->_Extensions.ARBFragmentProgram) // ARB implementation
+	{
+		nglGenProgramsARB(1, &ID);
+	}
+#endif
+}
+
+// ***************************************************************************
+
+bool CDriverGL::supportPixelProgram(CPixelProgram::TProfile profile) const
+{
+	H_AUTO_OGL(CPixelProgamDrvInfosGL_supportPixelProgram_profile)
+	switch (profile)
+	{
+	case CPixelProgram::arbfp1:
+		return _Extensions.ARBFragmentProgram;
+	case CPixelProgram::fp40:
+		return _Extensions.NVFragmentProgram2;
+	}
+	return false;
+}
+
+// ***************************************************************************
+
+bool CDriverGL::activePixelProgram(CPixelProgram *program)
+{
+	H_AUTO_OGL(CDriverGL_activePixelProgram)
+
+	if (_Extensions.ARBFragmentProgram)
+	{
+		return activeARBPixelProgram(program);
+	}
+
+	return false;
+}
+
+// ***************************************************************************
+
+bool CDriverGL::compilePixelProgram(NL3D::CPixelProgram *program)
+{
+#ifndef USE_OPENGLES
+	// Program setuped ?
+	if (program->m_DrvInfo == NULL)
+	{
+		glDisable(GL_FRAGMENT_PROGRAM_ARB);
+		_PixelProgramEnabled = false;
+		
+		// Insert into driver list. (so it is deleted when driver is deleted).
+		ItGPUPrgDrvInfoPtrList it = _GPUPrgDrvInfos.insert(_GPUPrgDrvInfos.end(), (NL3D::IProgramDrvInfos*)NULL);
+
+		// Create a driver info
+		CPixelProgamDrvInfosGL *drvInfo;
+		*it = drvInfo = new CPixelProgamDrvInfosGL(this, it);
+		// Set the pointer
+		program->m_DrvInfo = drvInfo;
+	
+		if (!setupPixelProgram(program, drvInfo->ID))
+		{
+			delete drvInfo;
+			program->m_DrvInfo = NULL;
+			_GPUPrgDrvInfos.erase(it);
+			return false;
+		}
+	}
+
+	return true;
+#else
+	return false;
+#endif
+}
+
+// ***************************************************************************
+
+bool CDriverGL::activeARBPixelProgram(CPixelProgram *program)
+{
+	H_AUTO_OGL(CDriverGL_activeARBPixelProgram)
+
+#ifndef USE_OPENGLES
+	// Setup or unsetup ?
+	if (program)
+	{
+		// Program setuped ?
+		if (!CDriverGL::compilePixelProgram(program)) return false;
+
+		// Cast the driver info pointer
+		CPixelProgamDrvInfosGL *drvInfo = safe_cast<CPixelProgamDrvInfosGL*>((IProgramDrvInfos*)program->m_DrvInfo);
+
+		glEnable(GL_FRAGMENT_PROGRAM_ARB);
+		_PixelProgramEnabled = true;
+		nglBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, drvInfo->ID);
+				
+		_LastSetuppedPP = program;
+	}
+	else
+	{		
+		glDisable(GL_FRAGMENT_PROGRAM_ARB);
+		_PixelProgramEnabled = false;
+	}
+	
+	return true;
+#else
+	return false;
+#endif
+}
+
+// ***************************************************************************
+
+bool CDriverGL::setupPixelProgram(CPixelProgram *program, GLuint id/*, bool &specularWritten*/)
+{
+	H_AUTO_OGL(CDriverGL_setupARBPixelProgram);
+	
+#ifndef USE_OPENGLES
+	CPixelProgamDrvInfosGL *drvInfo = static_cast<CPixelProgamDrvInfosGL *>((IProgramDrvInfos *)program->m_DrvInfo);
+
+	// Find a supported pixel program profile
+	IProgram::CSource *source = NULL;
+	for (uint i = 0; i < program->getSourceNb(); ++i)
+	{
+		if (supportPixelProgram(program->getSource(i)->Profile))
+		{
+			source = program->getSource(i);
+		}
+	}
+	if (!source)
+	{
+		nlwarning("No supported source profile for pixel program");
+		return false;
+	}
+
+	// Compile the program
+	nglBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, id);
+	glGetError();
+	nglProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, source->SourceLen, source->SourcePtr);
+	GLenum err = glGetError();
+	if (err != GL_NO_ERROR)
+	{
+		if (err == GL_INVALID_OPERATION)
+		{
+			GLint position;
+			glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &position);
+			nlassert(position != -1); // there was an error..
+			nlassert(position < (GLint) source->SourceLen);
+			uint line = 0;
+			const char *lineStart = source->SourcePtr;
+			for(uint k = 0; k < (uint) position; ++k)
+			{
+				if (source->SourcePtr[k] == '\n') 
+				{
+					lineStart = source->SourcePtr + k;
+					++line;
+				}
+			}
+			nlwarning("ARB fragment program parse error at line %d.", (int) line);
+			// search end of line
+			const char *lineEnd = source->SourcePtr + source->SourceLen;
+			for(uint k = position; k < source->SourceLen; ++k)
+			{
+				if (source->SourcePtr[k] == '\n')
+				{
+					lineEnd = source->SourcePtr + k;
+					break;
+				}
+			}
+			nlwarning(std::string(lineStart, lineEnd).c_str());
+			// display the gl error msg
+			const GLubyte *errorMsg = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
+			nlassert((const char *) errorMsg);
+			nlwarning((const char *) errorMsg);
+		}
+		nlassert(0);
+		return false;
+	}
+
+	// Set parameters for assembly programs
+	drvInfo->ParamIndices = source->ParamIndices;
+
+	// Build the feature info
+	program->buildInfo(source);
+
+	return true;
+#else
+	return false;
+#endif
+}
+
+#ifdef NL_STATIC
+} // NLDRIVERGL/ES
+#endif
+
+} // NL3D

code/nel/src/3d/driver/opengl/driver_opengl_texture.cpp

@@ -2323,7 +2323,7 @@ bool CDriverGL::setRenderTarget (ITexture *tex, uint32 x, uint32 y, uint32 width
 			newVP.init(0, 0, ((float)width/(float)w), ((float)height/(float)h));
 			setupViewport(newVP);
 
-			_RenderTargetFBO = true;
+			_RenderTargetFBO = tex;
 
 			return activeFrameBufferObject(tex);
 		}
@@ -2343,7 +2343,7 @@ bool CDriverGL::setRenderTarget (ITexture *tex, uint32 x, uint32 y, uint32 width
 		setupViewport(_OldViewport);
 		_OldViewport = _CurrViewport;
 
-		_RenderTargetFBO = false;
+		_RenderTargetFBO = NULL;
 		return false;
 	}
 
@@ -2356,12 +2356,17 @@ bool CDriverGL::setRenderTarget (ITexture *tex, uint32 x, uint32 y, uint32 width
 	// Update the scissor
 	setupScissor (_CurrScissor);
 
-	_RenderTargetFBO = false;
+	_RenderTargetFBO = NULL;
 	_OldViewport = _CurrViewport;
 
 	return true;
 }
 
+ITexture *CDriverGL::getRenderTarget() const
+{
+	return _RenderTargetFBO ? _RenderTargetFBO : _TextureTarget;
+}
+
 // ***************************************************************************
 
 bool CDriverGL::copyTargetToTexture (ITexture *tex,

code/nel/src/3d/driver/opengl/driver_opengl_uniform.cpp

@@ -0,0 +1,509 @@
+// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
+// Copyright (C) 2010  Winch Gate Property Limited
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "stdopengl.h"
+
+#include "driver_opengl.h"
+
+using namespace std;
+using namespace NLMISC;
+
+namespace NL3D {
+
+#ifdef NL_STATIC
+#ifdef USE_OPENGLES
+namespace NLDRIVERGLES {
+#else
+namespace NLDRIVERGL {
+#endif
+#endif
+
+inline void CDriverGL::setUniform4fInl(TProgram program, uint index, float f0, float f1, float f2, float f3)
+{
+	H_AUTO_OGL(CDriverGL_setUniform4f);
+
+#ifndef USE_OPENGLES
+	switch (program)
+	{
+	case VertexProgram:
+		if (_Extensions.NVVertexProgram)
+		{
+			// Setup constant
+			nglProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, index, f0, f1, f2, f3);
+		}
+		else if (_Extensions.ARBVertexProgram)
+		{
+			nglProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, index, f0, f1, f2, f3);
+		}
+		else if (_Extensions.EXTVertexShader)
+		{
+			float datas[] = { f0, f1, f2, f3 };
+			nglSetInvariantEXT(_EVSConstantHandle + index, GL_FLOAT, datas);
+		}
+		break;
+	case PixelProgram:
+		if (_Extensions.ARBFragmentProgram)
+		{
+			nglProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, index, f0, f1, f2, f3);
+		}
+		break;
+	}
+#endif
+}
+
+inline void CDriverGL::setUniform4fvInl(TProgram program, uint index, size_t num, const float *src)
+{
+	H_AUTO_OGL(CDriverGL_setUniform4fv);
+
+#ifndef USE_OPENGLES
+	switch (program)
+	{
+	case VertexProgram:
+		if (_Extensions.NVVertexProgram)
+		{
+			nglProgramParameters4fvNV(GL_VERTEX_PROGRAM_NV, index, num, src);
+		}
+		else if (_Extensions.ARBVertexProgram) // ARB pixel and geometry program will only exist when ARB vertex program exists
+		{
+			for (uint k = 0; k < num; ++k)
+			{
+				nglProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, index + k, src + 4 * k);
+			}
+		}
+		else if (_Extensions.EXTVertexShader)
+		{
+			for (uint k = 0; k < num; ++k)
+			{
+				nglSetInvariantEXT(_EVSConstantHandle + index + k, GL_FLOAT, (void *)(src + 4 * k));
+			}
+		}
+		break;
+	case PixelProgram:
+		if (_Extensions.ARBFragmentProgram) // ARB pixel and geometry program will only exist when ARB vertex program exists
+		{
+			for (uint k = 0; k < num; ++k)
+			{
+				nglProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, index + k, src + 4 * k);
+			}
+		}
+		break;
+	}
+#endif
+}
+
+void CDriverGL::setUniform1f(TProgram program, uint index, float f0)
+{
+	CDriverGL::setUniform4fInl(program, index, f0, 0.f, 0.f, 0.f);
+}
+
+void CDriverGL::setUniform2f(TProgram program, uint index, float f0, float f1)
+{
+	CDriverGL::setUniform4fInl(program, index, f0, f1, 0.f, 0.f);
+}
+
+void CDriverGL::setUniform3f(TProgram program, uint index, float f0, float f1, float f2)
+{
+	CDriverGL::setUniform4fInl(program, index, f0, f1, f2, 0.0f);
+}
+
+void CDriverGL::setUniform4f(TProgram program, uint index, float f0, float f1, float f2, float f3)
+{
+	CDriverGL::setUniform4fInl(program, index, f0, f1, f2, f3);
+}
+
+void CDriverGL::setUniform1i(TProgram program, uint index, sint32 i0)
+{
+
+}
+
+void CDriverGL::setUniform2i(TProgram program, uint index, sint32 i0, sint32 i1)
+{
+
+}
+
+void CDriverGL::setUniform3i(TProgram program, uint index, sint32 i0, sint32 i1, sint32 i2)
+{
+
+}
+
+void CDriverGL::setUniform4i(TProgram program, uint index, sint32 i0, sint32 i1, sint32 i2, sint32 i3)
+{
+
+}
+
+void CDriverGL::setUniform1ui(TProgram program, uint index, uint32 ui0)
+{
+
+}
+
+void CDriverGL::setUniform2ui(TProgram program, uint index, uint32 ui0, uint32 ui1)
+{
+
+}
+
+void CDriverGL::setUniform3ui(TProgram program, uint index, uint32 ui0, uint32 ui1, uint32 ui2)
+{
+
+}
+
+void CDriverGL::setUniform4ui(TProgram program, uint index, uint32 ui0, uint32 ui1, uint32 ui2, uint32 ui3)
+{
+
+}
+
+void CDriverGL::setUniform3f(TProgram program, uint index, const NLMISC::CVector& v)
+{
+	CDriverGL::setUniform4fInl(program, index, v.x, v.y, v.z, 0.f);
+}
+
+void CDriverGL::setUniform4f(TProgram program, uint index, const NLMISC::CVector& v, float f3)
+{
+	CDriverGL::setUniform4fInl(program, index, v.x, v.y, v.z, f3);
+}
+
+void CDriverGL::setUniform4f(TProgram program, uint index, const NLMISC::CRGBAF& rgba)
+{
+	CDriverGL::setUniform4fvInl(program, index, 1, &rgba.R);
+}
+
+void CDriverGL::setUniform4x4f(TProgram program, uint index, const NLMISC::CMatrix& m)
+{
+	H_AUTO_OGL(CDriverGL_setUniform4x4f);
+
+	// TODO: Verify this!
+	NLMISC::CMatrix mat = m;
+	mat.transpose();
+	const float *md = mat.get();
+
+	CDriverGL::setUniform4fvInl(program, index, 4, md);
+}
+
+void CDriverGL::setUniform4fv(TProgram program, uint index, size_t num, const float *src)
+{
+	CDriverGL::setUniform4fvInl(program, index, num, src);
+}
+
+void CDriverGL::setUniform4iv(TProgram program, uint index, size_t num, const sint32 *src)
+{
+	
+}
+
+void CDriverGL::setUniform4uiv(TProgram program, uint index, size_t num, const uint32 *src)
+{
+	
+}
+
+const uint CDriverGL::GLMatrix[IDriver::NumMatrix]=
+{
+	GL_MODELVIEW,
+	GL_PROJECTION,
+#ifdef USE_OPENGLES
+	GL_MODELVIEW
+#else
+	GL_MODELVIEW_PROJECTION_NV
+#endif
+};
+
+const uint CDriverGL::GLTransform[IDriver::NumTransform]=
+{
+#ifdef USE_OPENGLES
+	0,
+	0,
+	0,
+	0
+#else
+	GL_IDENTITY_NV,
+	GL_INVERSE_NV,
+	GL_TRANSPOSE_NV,
+	GL_INVERSE_TRANSPOSE_NV
+#endif
+};
+
+void CDriverGL::setUniformMatrix(NL3D::IDriver::TProgram program, uint index, NL3D::IDriver::TMatrix matrix, NL3D::IDriver::TTransform transform)
+{
+	H_AUTO_OGL(CDriverGL_setUniformMatrix);
+
+#ifndef USE_OPENGLES
+	// Vertex program exist ?
+	if (program == VertexProgram && _Extensions.NVVertexProgram)
+	{
+		// First, ensure that the render setup is correclty setuped.
+		refreshRenderSetup();
+
+		// Track the matrix
+		nglTrackMatrixNV(GL_VERTEX_PROGRAM_NV, index, GLMatrix[matrix], GLTransform[transform]);
+		// Release Track => matrix data is copied.
+		nglTrackMatrixNV(GL_VERTEX_PROGRAM_NV, index, GL_NONE, GL_IDENTITY_NV);
+	}
+	else
+	{
+		// First, ensure that the render setup is correctly setuped.
+		refreshRenderSetup();
+
+		CMatrix mat;
+		switch (matrix)
+		{
+			case IDriver::ModelView:
+				mat = _ModelViewMatrix;
+			break;
+			case IDriver::Projection:
+				{
+					refreshProjMatrixFromGL();
+					mat = _GLProjMat;
+				}
+			break;
+			case IDriver::ModelViewProjection:
+				refreshProjMatrixFromGL();
+				mat = _GLProjMat * _ModelViewMatrix;
+			break;
+            default:
+                break;
+		}
+
+		switch(transform)
+		{
+			case IDriver::Identity: break;
+			case IDriver::Inverse:
+				mat.invert();
+			break;
+			case IDriver::Transpose:
+				mat.transpose();
+			break;
+			case IDriver::InverseTranspose:
+				mat.invert();
+				mat.transpose();
+			break;
+            default:
+                break;
+		}
+
+		mat.transpose();
+		const float *md = mat.get();
+		
+		CDriverGL::setUniform4fvInl(program, index, 4, md);
+	}
+#endif
+}
+
+void CDriverGL::setUniformFog(NL3D::IDriver::TProgram program, uint index)
+{
+	H_AUTO_OGL(CDriverGL_setUniformFog)
+	
+	const float *values = _ModelViewMatrix.get();
+	CDriverGL::setUniform4fInl(program, index, -values[2], -values[6], -values[10], -values[14]);
+}
+
+/*
+
+bool CDriverGL::setUniformDriver(TProgram program)
+{
+	IProgram *prog = NULL;
+	switch (program)
+	{
+	case VertexProgram:
+		prog = _LastSetuppedVP;
+		break;
+	case PixelProgram:
+		prog = _LastSetuppedPP;
+		break;
+	}
+	if (!prog) return false;
+
+	const CProgramFeatures &features = prog->features();
+
+	if (features.DriverFlags)
+	{
+		if (features.DriverFlags & CProgramFeatures::Matrices)
+		{
+			if (prog->getUniformIndex(CProgramIndex::ModelView) != ~0)
+			{
+				setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ModelView), ModelView, Identity);
+			}
+			if (prog->getUniformIndex(CProgramIndex::ModelViewInverse) != ~0)
+			{
+				setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ModelViewInverse), ModelView, Inverse);
+			}
+			if (prog->getUniformIndex(CProgramIndex::ModelViewTranspose) != ~0)
+			{
+				setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ModelViewTranspose), ModelView, Transpose);
+			}
+			if (prog->getUniformIndex(CProgramIndex::ModelViewInverseTranspose) != ~0)
+			{
+				setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ModelViewInverseTranspose), ModelView, InverseTranspose);
+			}
+			if (prog->getUniformIndex(CProgramIndex::Projection) != ~0)
+			{
+				setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::Projection), Projection, Identity);
+			}
+			if (prog->getUniformIndex(CProgramIndex::ProjectionInverse) != ~0)
+			{
+				setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ProjectionInverse), Projection, Inverse);
+			}
+			if (prog->getUniformIndex(CProgramIndex::ProjectionTranspose) != ~0)
+			{
+				setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ProjectionTranspose), Projection, Transpose);
+			}
+			if (prog->getUniformIndex(CProgramIndex::ProjectionInverseTranspose) != ~0)
+			{
+				setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ProjectionInverseTranspose), Projection, InverseTranspose);
+			}
+			if (prog->getUniformIndex(CProgramIndex::ModelViewProjection) != ~0)
+			{
+				setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ModelViewProjection), ModelViewProjection, Identity);
+			}
+			if (prog->getUniformIndex(CProgramIndex::ModelViewProjectionInverse) != ~0)
+			{
+				setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ModelViewProjectionInverse), ModelViewProjection, Inverse);
+			}
+			if (prog->getUniformIndex(CProgramIndex::ModelViewProjectionTranspose) != ~0)
+			{
+				setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ModelViewProjectionTranspose), ModelViewProjection, Transpose);
+			}
+			if (prog->getUniformIndex(CProgramIndex::ModelViewProjectionInverseTranspose) != ~0)
+			{
+				setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ModelViewProjectionInverseTranspose), ModelViewProjection, InverseTranspose);
+			}
+		}
+		if (features.DriverFlags & CProgramFeatures::Fog)
+		{
+			if (prog->getUniformIndex(CProgramIndex::Fog) != ~0)
+			{
+				setUniformFog(program, prog->getUniformIndex(CProgramIndex::Fog));
+			}
+		}
+	}
+
+	return true;
+}
+
+bool CDriverGL::setUniformMaterial(TProgram program, CMaterial &material)
+{
+	IProgram *prog = NULL;
+	switch (program)
+	{
+	case VertexProgram:
+		prog = _LastSetuppedVP;
+		break;
+	case PixelProgram:
+		prog = _LastSetuppedPP;
+		break;
+	}
+	if (!prog) return false;
+
+	const CProgramFeatures &features = prog->features();
+
+	// These are also already set by setupMaterial, so setupMaterial uses setUniformMaterialInternal instead
+	if (features.MaterialFlags & (CProgramFeatures::TextureStages | CProgramFeatures::TextureMatrices))
+	{
+		if (features.MaterialFlags & CProgramFeatures::TextureStages)
+		{
+			for (uint stage = 0; stage < inlGetNumTextStages(); ++stage)
+			{
+				ITexture *text= material.getTexture(uint8(stage));
+
+				// Must setup textures each frame. (need to test if touched).
+				if (text != NULL && !setupTexture(*text))
+					return false;
+
+				// activate the texture, or disable texturing if NULL.
+				activateTexture(stage, text);
+
+				// If texture not NULL, Change texture env function.
+				setTextureEnvFunction(stage, material);
+			}
+
+			
+		}
+		if (features.MaterialFlags & CProgramFeatures::TextureMatrices)
+		{
+			// Textures user matrix
+			setupUserTextureMatrix(inlGetNumTextStages(), material);
+		}
+	}
+
+	return true;
+}
+
+bool CDriverGL::setUniformMaterialInternal(TProgram program, CMaterial &material)
+{
+	IProgram *prog = NULL;
+	switch (program)
+	{
+	case VertexProgram:
+		prog = _LastSetuppedVP;
+		break;
+	case PixelProgram:
+		prog = _LastSetuppedPP;
+		break;
+	}
+	if (!prog) return false;
+
+	const CProgramFeatures &features = prog->features();
+
+	if (features.MaterialFlags & ~(CProgramFeatures::TextureStages | CProgramFeatures::TextureMatrices))
+	{
+		// none
+	}
+
+	return true;
+}
+
+void CDriverGL::setUniformParams(TProgram program, CGPUProgramParams &params)
+{
+	IProgram *prog = NULL;
+	switch (program)
+	{
+	case VertexProgram:
+		prog = _LastSetuppedVP;
+		break;
+	case PixelProgram:
+		prog = _LastSetuppedPP;
+		break;
+	}
+	if (!prog) return;
+
+	size_t offset = params.getBegin();
+	while (offset != params.getEnd())
+	{
+		uint size = params.getSizeByOffset(offset);
+		uint count = params.getCountByOffset(offset);
+
+		nlassert(size == 4 || count == 1); // only support float4 arrays
+		nlassert(params.getTypeByOffset(offset) == CGPUProgramParams::Float); // only support float
+		
+		uint index = params.getIndexByOffset(offset);
+		if (index == ~0)
+		{
+			const std::string &name = params.getNameByOffset(offset);
+			nlassert(!name.empty() /* missing both parameter name and index, code error /);
+			uint index = prog->getUniformIndex(name.c_str());
+			nlassert(index != ~0 /* invalid parameter name /);
+			params.map(index, name);
+		}
+		
+		setUniform4fv(program, index, count, params.getPtrFByOffset(offset));
+
+		offset = params.getNext(offset);
+	}
+}
+
+*/
+
+#ifdef NL_STATIC
+} // NLDRIVERGL/ES
+#endif
+
+} // NL3D

code/nel/src/3d/driver/opengl/driver_opengl_vertex.cpp

@@ -1151,7 +1151,7 @@ void		CDriverGL::toggleGlArraysForEXTVertexShader()
 		CVertexProgram *vp = _LastSetuppedVP;
 		if (vp)
 		{
-			CVertexProgamDrvInfosGL *drvInfo = NLMISC::safe_cast<CVertexProgamDrvInfosGL *>((IVertexProgramDrvInfos *) vp->_DrvInfo);
+			CVertexProgamDrvInfosGL *drvInfo = NLMISC::safe_cast<CVertexProgamDrvInfosGL *>((IProgramDrvInfos *) vp->m_DrvInfo);
 			if (drvInfo)
 			{
 				// Disable all VertexAttribs.
@@ -1396,7 +1396,7 @@ void		CDriverGL::setupGlArraysForEXTVertexShader(CVertexBufferInfo &vb)
 
 	CVertexProgram *vp = _LastSetuppedVP;
 	if (!vp) return;
-	CVertexProgamDrvInfosGL *drvInfo = NLMISC::safe_cast<CVertexProgamDrvInfosGL *>((IVertexProgramDrvInfos *) vp->_DrvInfo);
+	CVertexProgamDrvInfosGL *drvInfo = NLMISC::safe_cast<CVertexProgamDrvInfosGL *>((IProgramDrvInfos *) vp->m_DrvInfo);
 	if (!drvInfo) return;
 
 	uint32	flags= vb.VertexFormat;

code/nel/src/3d/driver/opengl/driver_opengl_vertex_program.cpp

@@ -41,7 +41,7 @@ namespace NLDRIVERGL {
 #endif
 
 // ***************************************************************************
-CVertexProgamDrvInfosGL::CVertexProgamDrvInfosGL (CDriverGL *drv, ItVtxPrgDrvInfoPtrList it) : IVertexProgramDrvInfos (drv, it)
+CVertexProgamDrvInfosGL::CVertexProgamDrvInfosGL(CDriverGL *drv, ItGPUPrgDrvInfoPtrList it) : IProgramDrvInfos (drv, it)
 {
 	H_AUTO_OGL(CVertexProgamDrvInfosGL_CVertexProgamDrvInfosGL);
 
@@ -70,10 +70,11 @@ CVertexProgamDrvInfosGL::CVertexProgamDrvInfosGL (CDriverGL *drv, ItVtxPrgDrvInf
 
 
 // ***************************************************************************
-bool CDriverGL::isVertexProgramSupported () const
+bool CDriverGL::supportVertexProgram(CVertexProgram::TProfile profile) const
 {
-	H_AUTO_OGL(CVertexProgamDrvInfosGL_isVertexProgramSupported)
+	H_AUTO_OGL(CVertexProgamDrvInfosGL_supportVertexProgram)
-	return _Extensions.NVVertexProgram || _Extensions.EXTVertexShader || _Extensions.ARBVertexProgram;
+	return (profile == CVertexProgram::nelvp)
+		&& (_Extensions.NVVertexProgram || _Extensions.EXTVertexShader || _Extensions.ARBVertexProgram);
 }
 
 // ***************************************************************************
@@ -83,35 +84,41 @@ bool CDriverGL::isVertexProgramEmulated () const
 	return _Extensions.NVVertexProgramEmulated;
 }
 
-
+bool CDriverGL::compileNVVertexProgram(CVertexProgram *program)
-
-// ***************************************************************************
-bool CDriverGL::activeNVVertexProgram (CVertexProgram *program)
 {
-	H_AUTO_OGL(CVertexProgamDrvInfosGL_activeNVVertexProgram);
+	H_AUTO_OGL(CDriverGL_compileNVVertexProgram);
 
 #ifndef USE_OPENGLES
-	// Setup or unsetup ?
-	if (program)
-	{
-		// Enable vertex program
-		glEnable (GL_VERTEX_PROGRAM_NV);
-		_VertexProgramEnabled= true;
-
 
 	// Driver info
 	CVertexProgamDrvInfosGL *drvInfo;
 
-		// Program setuped ?
+	nlassert(!program->m_DrvInfo);
-		if (program->_DrvInfo==NULL)
+	glDisable(GL_VERTEX_PROGRAM_NV);
+	_VertexProgramEnabled = false;
+	
+	// Find nelvp
+	IProgram::CSource *source = NULL;
+	for (uint i = 0; i < program->getSourceNb(); ++i)
 	{
+		if (program->getSource(i)->Profile == CVertexProgram::nelvp)
+		{
+			source = program->getSource(i);
+		}
+	}
+	if (!source)
+	{
+		nlwarning("OpenGL driver only supports 'nelvp' profile, vertex program cannot be used");
+		return false;
+	}
+
 	/** Check with our parser if the program will works with other implemented extensions, too. (EXT_vertex_shader ..).
 	  * There are some incompatibilities.
 	  */
 	CVPParser parser;
 	CVPParser::TProgram parsedProgram;
 	std::string errorOutput;
-			bool result = parser.parse(program->getProgram().c_str(), parsedProgram, errorOutput);
+	bool result = parser.parse(source->SourcePtr, parsedProgram, errorOutput);
 	if (!result)
 	{
 		nlwarning("Unable to parse a vertex program :");
@@ -123,16 +130,16 @@ bool CDriverGL::activeNVVertexProgram (CVertexProgram *program)
 	}
 
 	// Insert into driver list. (so it is deleted when driver is deleted).
-			ItVtxPrgDrvInfoPtrList	it= _VtxPrgDrvInfos.insert(_VtxPrgDrvInfos.end(), (NL3D::IVertexProgramDrvInfos*)NULL);
+	ItGPUPrgDrvInfoPtrList it = _GPUPrgDrvInfos.insert(_GPUPrgDrvInfos.end(), (NL3D::IProgramDrvInfos*)NULL);
 
 	// Create a driver info
 	*it = drvInfo = new CVertexProgamDrvInfosGL(this, it);
 
 	// Set the pointer
-			program->_DrvInfo=drvInfo;
+	program->m_DrvInfo = drvInfo;
 
 	// Compile the program
-			nglLoadProgramNV (GL_VERTEX_PROGRAM_NV, drvInfo->ID, (GLsizei)program->getProgram().length(), (const GLubyte*)program->getProgram().c_str());
+	nglLoadProgramNV(GL_VERTEX_PROGRAM_NV, drvInfo->ID, (GLsizei)source->SourceLen, (const GLubyte*)source->SourcePtr);
 
 	// Get loading error code
 	GLint errorOff;
@@ -142,8 +149,8 @@ bool CDriverGL::activeNVVertexProgram (CVertexProgram *program)
 	if (errorOff >= 0)
 	{
 		// String length
-				uint length = (uint)program->getProgram ().length();
+		uint length = (uint)source->SourceLen;
-				const char* sString= program->getProgram ().c_str();
+		const char* sString = source->SourcePtr;
 
 		// Line count and char count
 		uint line=1;
@@ -168,22 +175,45 @@ bool CDriverGL::activeNVVertexProgram (CVertexProgram *program)
 		// Show the error
 		nlwarning("3D: Vertex program syntax error line %d character %d\n", line, charC);
 
-				// Disable vertex program
-				glDisable (GL_VERTEX_PROGRAM_NV);
-				_VertexProgramEnabled= false;
-
 		// Setup not ok
+		delete drvInfo;
+		program->m_DrvInfo = NULL;
+		_GPUPrgDrvInfos.erase(it);
 		return false;
 	}
 
+	// Set parameters for assembly programs
+	drvInfo->ParamIndices = source->ParamIndices;
+
+	// Build the feature info
+	program->buildInfo(source);
+
 	// Setup ok
 	return true;
+
+#else
+
+	return false;
+
+#endif
 }
-		else
+
+// ***************************************************************************
+bool CDriverGL::activeNVVertexProgram(CVertexProgram *program)
 {
-			// Cast the driver info pointer
+	H_AUTO_OGL(CVertexProgamDrvInfosGL_activeNVVertexProgram);
-			drvInfo=safe_cast<CVertexProgamDrvInfosGL*>((IVertexProgramDrvInfos*)program->_DrvInfo);
+
-		}
+#ifndef USE_OPENGLES
+	// Setup or unsetup ?
+	if (program)
+	{
+		// Driver info
+		CVertexProgamDrvInfosGL *drvInfo = safe_cast<CVertexProgamDrvInfosGL*>((IProgramDrvInfos*)program->m_DrvInfo);
+		nlassert(drvInfo);
+
+		// Enable vertex program
+		glEnable(GL_VERTEX_PROGRAM_NV);
+		_VertexProgramEnabled = true;
 
 		// Setup this program
 		nglBindProgramNV(GL_VERTEX_PROGRAM_NV, drvInfo->ID);
@@ -1486,28 +1516,38 @@ bool CDriverGL::setupARBVertexProgram (const CVPParser::TProgram &inParsedProgra
 #endif
 }
 
-
-
 // ***************************************************************************
-bool CDriverGL::activeARBVertexProgram (CVertexProgram *program)
+
+bool CDriverGL::compileARBVertexProgram(NL3D::CVertexProgram *program)
 {
-	H_AUTO_OGL(CDriverGL_activeARBVertexProgram);
+	H_AUTO_OGL(CDriverGL_compileARBVertexProgram);
 
 #ifndef USE_OPENGLES
-	// Setup or unsetup ?
-	if (program)
-	{
-		// Driver info
-		CVertexProgamDrvInfosGL *drvInfo;
 
-		// Program setuped ?
+	nlassert(!program->m_DrvInfo);
-		if (program->_DrvInfo==NULL)
+	glDisable(GL_VERTEX_PROGRAM_ARB);
+	_VertexProgramEnabled = false;
+
+	// Find nelvp
+	IProgram::CSource *source = NULL;
+	for (uint i = 0; i < program->getSourceNb(); ++i)
 	{
+		if (program->getSource(i)->Profile == CVertexProgram::nelvp)
+		{
+			source = program->getSource(i);
+		}
+	}
+	if (!source)
+	{
+		nlwarning("OpenGL driver only supports 'nelvp' profile, vertex program cannot be used");
+		return false;
+	}
+
 	// try to parse the program
 	CVPParser parser;
 	CVPParser::TProgram parsedProgram;
 	std::string errorOutput;
-			bool result = parser.parse(program->getProgram().c_str(), parsedProgram, errorOutput);
+	bool result = parser.parse(source->SourcePtr, parsedProgram, errorOutput);
 	if (!result)
 	{
 		nlwarning("Unable to parse a vertex program.");
@@ -1517,26 +1557,52 @@ bool CDriverGL::activeARBVertexProgram (CVertexProgram *program)
 		return false;
 	}
 	// Insert into driver list. (so it is deleted when driver is deleted).
-			ItVtxPrgDrvInfoPtrList	it= _VtxPrgDrvInfos.insert(_VtxPrgDrvInfos.end(), (NL3D::IVertexProgramDrvInfos*)NULL);
+	ItGPUPrgDrvInfoPtrList it = _GPUPrgDrvInfos.insert(_GPUPrgDrvInfos.end(), (NL3D::IProgramDrvInfos*)NULL);
 
 	// Create a driver info
+	CVertexProgamDrvInfosGL *drvInfo;
 	*it = drvInfo = new CVertexProgamDrvInfosGL(this, it);
 	// Set the pointer
-			program->_DrvInfo=drvInfo;
+	program->m_DrvInfo = drvInfo;
 
 	if (!setupARBVertexProgram(parsedProgram, drvInfo->ID, drvInfo->SpecularWritten))
 	{
 		delete drvInfo;
-				program->_DrvInfo = NULL;
+		program->m_DrvInfo = NULL;
-				_VtxPrgDrvInfos.erase(it);
+		_GPUPrgDrvInfos.erase(it);
 		return false;
 	}
+
+	// Set parameters for assembly programs
+	drvInfo->ParamIndices = source->ParamIndices;
+
+	// Build the feature info
+	program->buildInfo(source);
+
+	return true;
+
+#else
+
+	return false;
+
+#endif
 }
-		else
+
+// ***************************************************************************
+
+bool CDriverGL::activeARBVertexProgram(CVertexProgram *program)
 {
-			// Cast the driver info pointer
+	H_AUTO_OGL(CDriverGL_activeARBVertexProgram);
-			drvInfo=safe_cast<CVertexProgamDrvInfosGL*>((IVertexProgramDrvInfos*)program->_DrvInfo);
+
-		}
+#ifndef USE_OPENGLES
+
+	// Setup or unsetup ?
+	if (program)
+	{
+		// Driver info
+		CVertexProgamDrvInfosGL *drvInfo = safe_cast<CVertexProgamDrvInfosGL*>((IProgramDrvInfos*)program->m_DrvInfo);
+		nlassert(drvInfo);
+
 		glEnable( GL_VERTEX_PROGRAM_ARB );
 		_VertexProgramEnabled = true;
 		nglBindProgramARB(GL_VERTEX_PROGRAM_ARB, drvInfo->ID);
@@ -1557,31 +1623,46 @@ bool CDriverGL::activeARBVertexProgram (CVertexProgram *program)
 		_VertexProgramEnabled = false;
 	}
 	return true;
+
 #else
+
 	return false;
+
 #endif
 }
 
 // ***************************************************************************
-bool CDriverGL::activeEXTVertexShader (CVertexProgram *program)
+
+bool CDriverGL::compileEXTVertexShader(CVertexProgram *program)
 {
 	H_AUTO_OGL(CDriverGL_activeEXTVertexShader);
 
 #ifndef USE_OPENGLES
-	// Setup or unsetup ?
-	if (program)
-	{
-		// Driver info
-		CVertexProgamDrvInfosGL *drvInfo;
 
-		// Program setuped ?
+	nlassert(program->m_DrvInfo);
-		if (program->_DrvInfo==NULL)
+	glDisable(GL_VERTEX_SHADER_EXT);
+	_VertexProgramEnabled = false;
+
+	// Find nelvp
+	IProgram::CSource *source = NULL;
+	for (uint i = 0; i < program->getSourceNb(); ++i)
 	{
+		if (program->getSource(i)->Profile == CVertexProgram::nelvp)
+		{
+			source = program->getSource(i);
+		}
+	}
+	if (!source)
+	{
+		nlwarning("OpenGL driver only supports 'nelvp' profile, vertex program cannot be used");
+		return false;
+	}
+
 	// try to parse the program
 	CVPParser parser;
 	CVPParser::TProgram parsedProgram;
 	std::string errorOutput;
-			bool result = parser.parse(program->getProgram().c_str(), parsedProgram, errorOutput);
+	bool result = parser.parse(source->SourcePtr, parsedProgram, errorOutput);
 	if (!result)
 	{
 		nlwarning("Unable to parse a vertex program.");
@@ -1603,26 +1684,51 @@ bool CDriverGL::activeEXTVertexShader (CVertexProgram *program)
 	*/
 
 	// Insert into driver list. (so it is deleted when driver is deleted).
-			ItVtxPrgDrvInfoPtrList	it= _VtxPrgDrvInfos.insert(_VtxPrgDrvInfos.end(), (NL3D::IVertexProgramDrvInfos*)NULL);
+	ItGPUPrgDrvInfoPtrList	it= _GPUPrgDrvInfos.insert(_GPUPrgDrvInfos.end(), (NL3D::IProgramDrvInfos*)NULL);
 
 	// Create a driver info
+	CVertexProgamDrvInfosGL *drvInfo;
 	*it = drvInfo = new CVertexProgamDrvInfosGL (this, it);
 	// Set the pointer
-			program->_DrvInfo=drvInfo;
+	program->m_DrvInfo=drvInfo;
 
 	if (!setupEXTVertexShader(parsedProgram, drvInfo->ID, drvInfo->Variants, drvInfo->UsedVertexComponents))
 	{
 		delete drvInfo;
-				program->_DrvInfo = NULL;
+		program->m_DrvInfo = NULL;
-				_VtxPrgDrvInfos.erase(it);
+		_GPUPrgDrvInfos.erase(it);
 		return false;
 	}
+
+	// Set parameters for assembly programs
+	drvInfo->ParamIndices = source->ParamIndices;
+
+	// Build the feature info
+	program->buildInfo(source);
+
+	return true;
+
+#else
+
+	return false;
+
+#endif
 }
-		else
+
+// ***************************************************************************
+
+bool CDriverGL::activeEXTVertexShader(CVertexProgram *program)
 {
-			// Cast the driver info pointer
+	H_AUTO_OGL(CDriverGL_activeEXTVertexShader);
-			drvInfo=safe_cast<CVertexProgamDrvInfosGL*>((IVertexProgramDrvInfos*)program->_DrvInfo);
+
-		}
+#ifndef USE_OPENGLES
+
+	// Setup or unsetup ?
+	if (program)
+	{
+		// Driver info
+		CVertexProgamDrvInfosGL *drvInfo = safe_cast<CVertexProgamDrvInfosGL*>((IProgramDrvInfos*)program->m_DrvInfo);
+		nlassert(drvInfo);
 
 		glEnable(GL_VERTEX_SHADER_EXT);
 		_VertexProgramEnabled = true;
@@ -1635,16 +1741,48 @@ bool CDriverGL::activeEXTVertexShader (CVertexProgram *program)
 		_VertexProgramEnabled = false;
 	}
 	return true;
+
 #else
+
 	return false;
+
 #endif
 }
 
+bool CDriverGL::compileVertexProgram(NL3D::CVertexProgram *program)
+{
+	if (program->m_DrvInfo == NULL)
+	{
+		// Extension
+		if (_Extensions.NVVertexProgram)
+		{
+			return compileNVVertexProgram(program);
+		}
+		else if (_Extensions.ARBVertexProgram)
+		{
+			return compileARBVertexProgram(program);
+		}
+		else if (_Extensions.EXTVertexShader)
+		{
+			return compileEXTVertexShader(program);
+		}
+
+		// Can't do anything
+		return false;
+	}
+	return true;
+}
+
 // ***************************************************************************
+
 bool CDriverGL::activeVertexProgram(CVertexProgram *program)
 {
 	H_AUTO_OGL(CDriverGL_activeVertexProgram)
-	// Extension here ?
+
+	// Compile if necessary
+	if (program && !CDriverGL::compileVertexProgram(program)) return false;
+
+	// Extension
 	if (_Extensions.NVVertexProgram)
 	{
 		return activeNVVertexProgram(program);
@@ -1662,287 +1800,6 @@ bool CDriverGL::activeVertexProgram (CVertexProgram *program)
 	return false;
 }
 
-
-// ***************************************************************************
-
-void CDriverGL::setConstant (uint index, float f0, float f1, float f2, float f3)
-{
-	H_AUTO_OGL(CDriverGL_setConstant);
-
-#ifndef USE_OPENGLES
-	// Vertex program exist ?
-	if (_Extensions.NVVertexProgram)
-	{
-		// Setup constant
-		nglProgramParameter4fNV (GL_VERTEX_PROGRAM_NV, index, f0, f1, f2, f3);
-	}
-	else if (_Extensions.ARBVertexProgram)
-	{
-		nglProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, index, f0, f1, f2, f3);
-	}
-	else if (_Extensions.EXTVertexShader)
-	{
-		float datas[] = { f0, f1, f2, f3 };
-		nglSetInvariantEXT(_EVSConstantHandle + index, GL_FLOAT, datas);
-	}
-#endif
-}
-
-
-// ***************************************************************************
-
-void CDriverGL::setConstant (uint index, double d0, double d1, double d2, double d3)
-{
-	H_AUTO_OGL(CDriverGL_setConstant);
-
-#ifndef USE_OPENGLES
-	// Vertex program exist ?
-	if (_Extensions.NVVertexProgram)
-	{
-		// Setup constant
-		nglProgramParameter4dNV (GL_VERTEX_PROGRAM_NV, index, d0, d1, d2, d3);
-	}
-	else if (_Extensions.ARBVertexProgram)
-	{
-		nglProgramEnvParameter4dARB(GL_VERTEX_PROGRAM_ARB, index, d0, d1, d2, d3);
-	}
-	else if (_Extensions.EXTVertexShader)
-	{
-		double datas[] = { d0, d1, d2, d3 };
-		nglSetInvariantEXT(_EVSConstantHandle + index, GL_DOUBLE, datas);
-	}
-#endif
-}
-
-
-// ***************************************************************************
-
-void CDriverGL::setConstant (uint index, const NLMISC::CVector& value)
-{
-	H_AUTO_OGL(CDriverGL_setConstant);
-
-#ifndef USE_OPENGLES
-	// Vertex program exist ?
-	if (_Extensions.NVVertexProgram)
-	{
-		// Setup constant
-		nglProgramParameter4fNV (GL_VERTEX_PROGRAM_NV, index, value.x, value.y, value.z, 0);
-	}
-	else if (_Extensions.ARBVertexProgram)
-	{
-		nglProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, index, value.x, value.y, value.z, 0);
-	}
-	else if (_Extensions.EXTVertexShader)
-	{
-		float datas[] = { value.x, value.y, value.z, 0 };
-		nglSetInvariantEXT(_EVSConstantHandle + index, GL_FLOAT, datas);
-	}
-#endif
-}
-
-
-// ***************************************************************************
-
-void CDriverGL::setConstant (uint index, const NLMISC::CVectorD& value)
-{
-	H_AUTO_OGL(CDriverGL_setConstant);
-
-#ifndef USE_OPENGLES
-	// Vertex program exist ?
-	if (_Extensions.NVVertexProgram)
-	{
-		// Setup constant
-		nglProgramParameter4dNV (GL_VERTEX_PROGRAM_NV, index, value.x, value.y, value.z, 0);
-	}
-	else if (_Extensions.ARBVertexProgram)
-	{
-		nglProgramEnvParameter4dARB(GL_VERTEX_PROGRAM_ARB, index, value.x, value.y, value.z, 0);
-	}
-	else if (_Extensions.EXTVertexShader)
-	{
-		double datas[] = { value.x, value.y, value.z, 0 };
-		nglSetInvariantEXT(_EVSConstantHandle + index, GL_DOUBLE, datas);
-	}
-#endif
-}
-
-
-// ***************************************************************************
-void	CDriverGL::setConstant (uint index, uint num, const float *src)
-{
-	H_AUTO_OGL(CDriverGL_setConstant);
-
-#ifndef USE_OPENGLES
-	// Vertex program exist ?
-	if (_Extensions.NVVertexProgram)
-	{
-		nglProgramParameters4fvNV(GL_VERTEX_PROGRAM_NV, index, num, src);
-	}
-	else if (_Extensions.ARBVertexProgram)
-	{
-		for(uint k = 0; k < num; ++k)
-		{
-			nglProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, index + k, src + 4 * k);
-		}
-	}
-	else if (_Extensions.EXTVertexShader)
-	{
-		for(uint k = 0; k < num; ++k)
-		{
-			nglSetInvariantEXT(_EVSConstantHandle + index + k, GL_FLOAT, (void *) (src + 4 * k));
-		}
-	}
-#endif
-}
-
-// ***************************************************************************
-void	CDriverGL::setConstant (uint index, uint num, const double *src)
-{
-	H_AUTO_OGL(CDriverGL_setConstant);
-
-#ifndef USE_OPENGLES
-	// Vertex program exist ?
-	if (_Extensions.NVVertexProgram)
-	{
-		nglProgramParameters4dvNV(GL_VERTEX_PROGRAM_NV, index, num, src);
-	}
-	else if (_Extensions.ARBVertexProgram)
-	{
-		for(uint k = 0; k < num; ++k)
-		{
-			nglProgramEnvParameter4dvARB(GL_VERTEX_PROGRAM_ARB, index + k, src + 4 * k);
-		}
-	}
-	else if (_Extensions.EXTVertexShader)
-	{
-		for(uint k = 0; k < num; ++k)
-		{
-			nglSetInvariantEXT(_EVSConstantHandle + index + k, GL_DOUBLE, (void *) (src + 4 * k));
-		}
-	}
-#endif
-}
-
-// ***************************************************************************
-
-const uint CDriverGL::GLMatrix[IDriver::NumMatrix]=
-{
-	GL_MODELVIEW,
-	GL_PROJECTION,
-#ifdef USE_OPENGLES
-	GL_MODELVIEW
-#else
-	GL_MODELVIEW_PROJECTION_NV
-#endif
-};
-
-
-// ***************************************************************************
-
-const uint CDriverGL::GLTransform[IDriver::NumTransform]=
-{
-#ifdef USE_OPENGLES
-	0,
-	0,
-	0,
-	0
-#else
-	GL_IDENTITY_NV,
-	GL_INVERSE_NV,
-	GL_TRANSPOSE_NV,
-	GL_INVERSE_TRANSPOSE_NV
-#endif
-};
-
-
-// ***************************************************************************
-
-void CDriverGL::setConstantMatrix (uint index, IDriver::TMatrix matrix, IDriver::TTransform transform)
-{
-	H_AUTO_OGL(CDriverGL_setConstantMatrix);
-
-#ifndef USE_OPENGLES
-	// Vertex program exist ?
-	if (_Extensions.NVVertexProgram)
-	{
-		// First, ensure that the render setup is correclty setuped.
-		refreshRenderSetup();
-
-		// Track the matrix
-		nglTrackMatrixNV (GL_VERTEX_PROGRAM_NV, index, GLMatrix[matrix], GLTransform[transform]);
-		// Release Track => matrix data is copied.
-		nglTrackMatrixNV (GL_VERTEX_PROGRAM_NV, index, GL_NONE, GL_IDENTITY_NV);
-	}
-	else
-	{
-		// First, ensure that the render setup is correctly setuped.
-		refreshRenderSetup();
-		CMatrix mat;
-		switch (matrix)
-		{
-			case IDriver::ModelView:
-				mat = _ModelViewMatrix;
-			break;
-			case IDriver::Projection:
-				{
-					refreshProjMatrixFromGL();
-					mat = _GLProjMat;
-				}
-			break;
-			case IDriver::ModelViewProjection:
-				refreshProjMatrixFromGL();
-				mat = _GLProjMat * _ModelViewMatrix;
-			break;
-            default:
-                break;
-		}
-
-		switch(transform)
-		{
-			case IDriver::Identity: break;
-			case IDriver::Inverse:
-				mat.invert();
-			break;
-			case IDriver::Transpose:
-				mat.transpose();
-			break;
-			case IDriver::InverseTranspose:
-				mat.invert();
-				mat.transpose();
-			break;
-            default:
-                break;
-		}
-		mat.transpose();
-		float matDatas[16];
-		mat.get(matDatas);
-		if (_Extensions.ARBVertexProgram)
-		{
-			nglProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, index, matDatas);
-			nglProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, index + 1, matDatas + 4);
-			nglProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, index + 2, matDatas + 8);
-			nglProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, index + 3, matDatas + 12);
-		}
-		else
-		{
-			nglSetInvariantEXT(_EVSConstantHandle + index, GL_FLOAT, matDatas);
-			nglSetInvariantEXT(_EVSConstantHandle + index + 1, GL_FLOAT, matDatas + 4);
-			nglSetInvariantEXT(_EVSConstantHandle + index + 2, GL_FLOAT, matDatas + 8);
-			nglSetInvariantEXT(_EVSConstantHandle + index + 3, GL_FLOAT, matDatas + 12);
-		}
-	}
-#endif
-}
-
-// ***************************************************************************
-
-void CDriverGL::setConstantFog (uint index)
-{
-	H_AUTO_OGL(CDriverGL_setConstantFog)
-	const float *values = _ModelViewMatrix.get();
-	setConstant (index, -values[2], -values[6], -values[10], -values[14]);
-}
-
 // ***************************************************************************
 
 void CDriverGL::enableVertexProgramDoubleSidedColor(bool doubleSided)

code/nel/src/3d/driver_user.cpp

@@ -213,6 +213,12 @@ void			CDriverUser::disableHardwareVertexProgram()
 
 	_Driver->disableHardwareVertexProgram();
 }
+void			CDriverUser::disableHardwarePixelProgram()
+{
+	NL3D_HAUTO_UI_DRIVER;
+
+	_Driver->disableHardwarePixelProgram();
+}
 void			CDriverUser::disableHardwareVertexArrayAGP()
 {
 	NL3D_HAUTO_UI_DRIVER;
@@ -1490,12 +1496,6 @@ void			CDriverUser::forceTextureResize(uint divisor)
 
 	_Driver->forceTextureResize(divisor);
 }
-void			CDriverUser::forceNativeFragmentPrograms(bool nativeOnly)
-{
-	NL3D_HAUTO_UI_DRIVER;
-
-	_Driver->forceNativeFragmentPrograms(nativeOnly);
-}
 bool			CDriverUser::setMonitorColorProperties (const CMonitorColorProperties &properties)
 {
 	NL3D_HAUTO_UI_DRIVER;

code/nel/src/3d/flare_model.cpp

@@ -363,6 +363,8 @@ void	CFlareModel::traverseRender()
 	}
 	// setup driver
 	drv->activeVertexProgram(NULL);
+	drv->activePixelProgram(NULL);
+	drv->activeGeometryProgram(NULL);
 	drv->setupModelMatrix(fs->getLookAtMode() ? CMatrix::Identity : getWorldMatrix());
 	// we don't change the fustrum to draw 2d shapes : it is costly, and we need to restore it after the drawing has been done
 	// we setup Z to be (near + far) / 2, and setup x and y to get the screen coordinates we want
@@ -565,6 +567,8 @@ void CFlareModel::updateOcclusionQueryBegin(IDriver *drv)
 {
 	nlassert(drv);
 	drv->activeVertexProgram(NULL);
+	drv->activePixelProgram(NULL);
+	drv->activeGeometryProgram(NULL);
 	drv->setupModelMatrix(CMatrix::Identity);
 	initStatics();
 	drv->setColorMask(false, false, false, false); // don't write any pixel during the test
@@ -661,6 +665,8 @@ void CFlareModel::occlusionTest(CMesh &mesh, IDriver &drv)
 	}
 	drv.setColorMask(false, false, false, false); // don't write any pixel during the test
 	drv.activeVertexProgram(NULL);
+	drv.activePixelProgram(NULL);
+	drv.activeGeometryProgram(NULL);
 	setupOcclusionMeshMatrix(drv, *_Scene);
 	drv.activeVertexBuffer(const_cast<CVertexBuffer &>(mesh.getVertexBuffer()));
 	// query drawn count

code/nel/src/3d/geometry_program.cpp

@@ -0,0 +1,49 @@
+/** \file geometry_program.cpp
+ * Geometry program definition
+ */
+
+/* Copyright, 2000, 2001 Nevrax Ltd.
+ *
+ * This file is part of NEVRAX NEL.
+ * NEVRAX NEL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+
+ * NEVRAX NEL is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with NEVRAX NEL; see the file COPYING. If not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ */
+
+#include "std3d.h"
+
+#include <nel/3d/geometry_program.h>
+
+#include <nel/3d/driver.h>
+
+namespace NL3D 
+{
+
+// ***************************************************************************
+
+CGeometryProgram::CGeometryProgram()
+{
+	
+}
+
+// ***************************************************************************
+
+CGeometryProgram::~CGeometryProgram ()
+{
+	
+}
+
+// ***************************************************************************
+
+} // NL3D

code/nel/src/3d/gpu_program_params.cpp

@@ -0,0 +1,587 @@
+/**
+ * \file gpu_program_params.cpp
+ * \brief CGPUProgramParams
+ * \date 2013-09-07 22:17GMT
+ * \author Jan Boon (Kaetemi)
+ * CGPUProgramParams
+ */
+
+/* 
+ * Copyright (C) 2013  by authors
+ * 
+ * This file is part of NL3D.
+ * NL3D is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * NL3D is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
+ * Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public
+ * License along with NL3D.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include <nel/misc/types_nl.h>
+#include <nel/3d/gpu_program_params.h>
+
+// STL includes
+
+// NeL includes
+// #include <nel/misc/debug.h>
+#include <nel/misc/vector.h>
+#include <nel/misc/matrix.h>
+
+// Project includes
+#include <nel/3d/driver.h>
+
+using namespace std;
+// using namespace NLMISC;
+
+namespace NL3D {
+
+CGPUProgramParams::CGPUProgramParams() : m_First(s_End), m_Last(s_End)
+{
+	
+}
+
+CGPUProgramParams::~CGPUProgramParams()
+{
+	
+}
+
+void CGPUProgramParams::copy(CGPUProgramParams *params)
+{
+	size_t offset = params->getBegin();
+	while (offset != params->getEnd())
+	{
+		uint index = params->getIndexByOffset(offset);
+		const std::string &name = params->getNameByOffset(offset);
+		size_t local;
+		uint size = params->getSizeByOffset(offset);
+		uint count = params->getCountByOffset(offset);
+		uint nbComponents = size * count;
+		if (index)
+		{
+			local = allocOffset(index, size, count, params->getTypeByOffset(offset));
+			if (!name.empty())
+			{
+				map(index, name);
+			}
+		}
+		else
+		{
+			nlassert(!name.empty());
+			local = allocOffset(name, size, count, params->getTypeByOffset(offset));
+		}
+		
+		uint32 *src = params->getPtrUIByOffset(offset);
+		uint32 *dst = getPtrUIByOffset(local);
+
+		for (uint c = 0; c < nbComponents; ++c)
+		{
+			dst[c] = src[c];
+		}
+
+		offset = params->getNext(offset);
+	}
+}
+
+void CGPUProgramParams::set1f(uint index, float f0)
+{
+	float *f = getPtrFByOffset(allocOffset(index, 1, 1, Float));
+	f[0] = f0;
+}
+
+void CGPUProgramParams::set2f(uint index, float f0, float f1)
+{
+	float *f = getPtrFByOffset(allocOffset(index, 2, 1, Float));
+	f[0] = f0;
+	f[1] = f1;
+}
+
+void CGPUProgramParams::set3f(uint index, float f0, float f1, float f2)
+{
+	float *f = getPtrFByOffset(allocOffset(index, 3, 1, Float));
+	f[0] = f0;
+	f[1] = f1;
+	f[2] = f2;
+}
+
+void CGPUProgramParams::set4f(uint index, float f0, float f1, float f2, float f3)
+{
+	float *f = getPtrFByOffset(allocOffset(index, 4, 1, Float));
+	f[0] = f0;
+	f[1] = f1;
+	f[2] = f2;
+	f[3] = f3;
+}
+
+void CGPUProgramParams::set1i(uint index, sint32 i0)
+{
+	sint32 *i = getPtrIByOffset(allocOffset(index, 1, 1, Int));
+	i[0] = i0;
+}
+
+void CGPUProgramParams::set2i(uint index, sint32 i0, sint32 i1)
+{
+	sint32 *i = getPtrIByOffset(allocOffset(index, 2, 1, Int));
+	i[0] = i0;
+	i[1] = i1;
+}
+
+void CGPUProgramParams::set3i(uint index, sint32 i0, sint32 i1, sint32 i2)
+{
+	sint32 *i = getPtrIByOffset(allocOffset(index, 3, 1, Int));
+	i[0] = i0;
+	i[1] = i1;
+	i[2] = i2;
+}
+
+void CGPUProgramParams::set4i(uint index, sint32 i0, sint32 i1, sint32 i2, sint32 i3)
+{
+	sint32 *i = getPtrIByOffset(allocOffset(index, 4, 1, Int));
+	i[0] = i0;
+	i[1] = i1;
+	i[2] = i2;
+	i[3] = i3;
+}
+
+void CGPUProgramParams::set1ui(uint index, uint32 ui0)
+{
+	uint32 *ui = getPtrUIByOffset(allocOffset(index, 1, 1, UInt));
+	ui[0] = ui0;
+}
+
+void CGPUProgramParams::set2ui(uint index, uint32 ui0, uint32 ui1)
+{
+	uint32 *ui = getPtrUIByOffset(allocOffset(index, 2, 1, UInt));
+	ui[0] = ui0;
+	ui[1] = ui1;
+}
+
+void CGPUProgramParams::set3ui(uint index, uint32 ui0, uint32 ui1, uint32 ui2)
+{
+	uint32 *ui = getPtrUIByOffset(allocOffset(index, 3, 1, UInt));
+	ui[0] = ui0;
+	ui[1] = ui1;
+	ui[2] = ui2;
+}
+
+void CGPUProgramParams::set4ui(uint index, uint32 ui0, uint32 ui1, uint32 ui2, uint32 ui3)
+{
+	uint32 *ui = getPtrUIByOffset(allocOffset(index, 4, 1, UInt));
+	ui[0] = ui0;
+	ui[1] = ui1;
+	ui[2] = ui2;
+	ui[3] = ui3;
+}
+
+void CGPUProgramParams::set3f(uint index, const NLMISC::CVector& v)
+{
+	float *f = getPtrFByOffset(allocOffset(index, 3, 1, Float));
+	f[0] = v.x;
+	f[1] = v.y;
+	f[2] = v.z;
+}
+
+void CGPUProgramParams::set4f(uint index, const NLMISC::CVector& v, float f3)
+{
+	float *f = getPtrFByOffset(allocOffset(index, 4, 1, Float));
+	f[0] = v.x;
+	f[1] = v.y;
+	f[2] = v.z;
+	f[3] = f3;
+}
+
+void CGPUProgramParams::set4x4f(uint index, const NLMISC::CMatrix& m)
+{
+	// TODO: Verify this!
+	float *f = getPtrFByOffset(allocOffset(index, 4, 4, Float));
+	NLMISC::CMatrix mt = m;
+	mt.transpose();
+	mt.get(f);
+}
+
+void CGPUProgramParams::set4fv(uint index, size_t num, const float *src)
+{
+	float *f = getPtrFByOffset(allocOffset(index, 4, num, Float));
+	size_t nb = 4 * num;
+	for (uint c = 0; c < nb; ++c)
+		f[c] = src[c];
+}
+
+void CGPUProgramParams::set4iv(uint index, size_t num, const sint32 *src)
+{
+	sint32 *i = getPtrIByOffset(allocOffset(index, 4, num, Int));
+	size_t nb = 4 * num;
+	for (uint c = 0; c < nb; ++c)
+		i[c] = src[c];
+}
+
+void CGPUProgramParams::set4uiv(uint index, size_t num, const uint32 *src)
+{
+	uint32 *ui = getPtrUIByOffset(allocOffset(index, 4, num, UInt));
+	size_t nb = 4 * num;
+	for (uint c = 0; c < nb; ++c)
+		ui[c] = src[c];
+}
+
+void CGPUProgramParams::unset(uint index)
+{
+	size_t offset = getOffset(index);
+	if (offset != getEnd())
+	{
+		freeOffset(offset);
+	}
+}
+
+void CGPUProgramParams::set1f(const std::string &name, float f0)
+{
+	float *f = getPtrFByOffset(allocOffset(name, 1, 1, Float));
+	f[0] = f0;
+}
+
+void CGPUProgramParams::set2f(const std::string &name, float f0, float f1)
+{
+	float *f = getPtrFByOffset(allocOffset(name, 2, 1, Float));
+	f[0] = f0;
+	f[1] = f1;
+}
+
+void CGPUProgramParams::set3f(const std::string &name, float f0, float f1, float f2)
+{
+	float *f = getPtrFByOffset(allocOffset(name, 3, 1, Float));
+	f[0] = f0;
+	f[1] = f1;
+	f[2] = f2;
+}
+
+void CGPUProgramParams::set4f(const std::string &name, float f0, float f1, float f2, float f3)
+{
+	float *f = getPtrFByOffset(allocOffset(name, 4, 1, Float));
+	f[0] = f0;
+	f[1] = f1;
+	f[2] = f2;
+	f[3] = f3;
+}
+
+void CGPUProgramParams::set1i(const std::string &name, sint32 i0)
+{
+	sint32 *i = getPtrIByOffset(allocOffset(name, 1, 1, Int));
+	i[0] = i0;
+}
+
+void CGPUProgramParams::set2i(const std::string &name, sint32 i0, sint32 i1)
+{
+	sint32 *i = getPtrIByOffset(allocOffset(name, 2, 1, Int));
+	i[0] = i0;
+	i[1] = i1;
+}
+
+void CGPUProgramParams::set3i(const std::string &name, sint32 i0, sint32 i1, sint32 i2)
+{
+	sint32 *i = getPtrIByOffset(allocOffset(name, 3, 1, Int));
+	i[0] = i0;
+	i[1] = i1;
+	i[2] = i2;
+}
+
+void CGPUProgramParams::set4i(const std::string &name, sint32 i0, sint32 i1, sint32 i2, sint32 i3)
+{
+	sint32 *i = getPtrIByOffset(allocOffset(name, 4, 1, Int));
+	i[0] = i0;
+	i[1] = i1;
+	i[2] = i2;
+	i[3] = i3;
+}
+
+void CGPUProgramParams::set1ui(const std::string &name, uint32 ui0)
+{
+	uint32 *ui = getPtrUIByOffset(allocOffset(name, 1, 1, UInt));
+	ui[0] = ui0;
+}
+
+void CGPUProgramParams::set2ui(const std::string &name, uint32 ui0, uint32 ui1)
+{
+	uint32 *ui = getPtrUIByOffset(allocOffset(name, 2, 1, UInt));
+	ui[0] = ui0;
+	ui[1] = ui1;
+}
+
+void CGPUProgramParams::set3ui(const std::string &name, uint32 ui0, uint32 ui1, uint32 ui2)
+{
+	uint32 *ui = getPtrUIByOffset(allocOffset(name, 3, 1, UInt));
+	ui[0] = ui0;
+	ui[1] = ui1;
+	ui[2] = ui2;
+}
+
+void CGPUProgramParams::set4ui(const std::string &name, uint32 ui0, uint32 ui1, uint32 ui2, uint32 ui3)
+{
+	uint32 *ui = getPtrUIByOffset(allocOffset(name, 4, 1, UInt));
+	ui[0] = ui0;
+	ui[1] = ui1;
+	ui[2] = ui2;
+	ui[3] = ui3;
+}
+
+void CGPUProgramParams::set3f(const std::string &name, const NLMISC::CVector& v)
+{
+	float *f = getPtrFByOffset(allocOffset(name, 3, 1, Float));
+	f[0] = v.x;
+	f[1] = v.y;
+	f[2] = v.z;
+}
+
+void CGPUProgramParams::set4f(const std::string &name, const NLMISC::CVector& v, float f3)
+{
+	float *f = getPtrFByOffset(allocOffset(name, 4, 1, Float));
+	f[0] = v.x;
+	f[1] = v.y;
+	f[2] = v.z;
+	f[3] = f3;
+}
+
+void CGPUProgramParams::set4x4f(const std::string &name, const NLMISC::CMatrix& m)
+{
+	// TODO: Verify this!
+	float *f = getPtrFByOffset(allocOffset(name, 4, 4, Float));
+	NLMISC::CMatrix mt = m;
+	mt.transpose();
+	mt.get(f);
+}
+
+void CGPUProgramParams::set4fv(const std::string &name, size_t num, const float *src)
+{
+	float *f = getPtrFByOffset(allocOffset(name, 4, num, Float));
+	size_t nb = 4 * num;
+	for (uint c = 0; c < nb; ++c)
+		f[c] = src[c];
+}
+
+void CGPUProgramParams::set4iv(const std::string &name, size_t num, const sint32 *src)
+{
+	sint32 *i = getPtrIByOffset(allocOffset(name, 4, num, Int));
+	size_t nb = 4 * num;
+	for (uint c = 0; c < nb; ++c)
+		i[c] = src[c];
+}
+
+void CGPUProgramParams::set4uiv(const std::string &name, size_t num, const uint32 *src)
+{
+	uint32 *ui = getPtrUIByOffset(allocOffset(name, 4, num, UInt));
+	size_t nb = 4 * num;
+	for (uint c = 0; c < nb; ++c)
+		ui[c] = src[c];
+}
+
+void CGPUProgramParams::unset(const std::string &name)
+{
+	size_t offset = getOffset(name);
+	if (offset != getEnd())
+	{
+		freeOffset(offset);
+	}
+}
+
+void CGPUProgramParams::map(uint index, const std::string &name)
+{
+	size_t offsetIndex = getOffset(index);
+	size_t offsetName = getOffset(name);
+	if (offsetName != getEnd())
+	{
+		// Remove possible duplicate
+		if (offsetIndex != getEnd())
+		{
+			freeOffset(offsetIndex);
+		}
+
+		// Set index
+		m_Meta[offsetName].Index = index;
+
+		// Map index to name
+		if (index >= m_Map.size())
+			m_Map.resize(index + 1, s_End);
+		m_Map[index] = offsetName;
+	}
+	else if (offsetIndex != getEnd())
+	{
+		// Set name
+		m_Meta[offsetIndex].Name = name;
+
+		// Map name to index
+		m_MapName[name] = offsetIndex;
+	}
+}
+
+/// Allocate specified number of components if necessary
+size_t CGPUProgramParams::allocOffset(uint index, uint size, uint count, TType type)
+{
+	nlassert(count > 0); // this code will not properly handle 0
+	nlassert(size > 0); // this code will not properly handle 0
+	nlassert(index < 0xFFFF); // sanity check
+
+	uint nbComponents = size * count;
+	size_t offset = getOffset(index);
+	if (offset != s_End)
+	{
+		if (getCountByOffset(offset) >= nbComponents)
+		{
+			m_Meta[offset].Type = type;
+			m_Meta[offset].Size = size;
+			m_Meta[offset].Count = count;
+			return offset;
+		}
+		if (getCountByOffset(offset) < nbComponents)
+		{
+			freeOffset(offset);
+		}
+	}
+
+	// Allocate space
+	offset = allocOffset(size, count, type);
+
+	// Fill
+	m_Meta[offset].Index = index;
+
+	// Store offset in map
+	if (index >= m_Map.size())
+		m_Map.resize(index + 1, s_End);
+	m_Map[index] = offset;
+
+	return offset;
+}
+
+/// Allocate specified number of components if necessary
+size_t CGPUProgramParams::allocOffset(const std::string &name, uint size, uint count, TType type)
+{
+	nlassert(count > 0); // this code will not properly handle 0
+	nlassert(size > 0); // this code will not properly handle 0
+	nlassert(!name.empty()); // sanity check
+
+	uint nbComponents = size * count;
+	size_t offset = getOffset(name);
+	if (offset != s_End)
+	{
+		if (getCountByOffset(offset) >= nbComponents)
+		{
+			m_Meta[offset].Type = type;
+			m_Meta[offset].Size = size;
+			m_Meta[offset].Count = count;
+			return offset;
+		}
+		if (getCountByOffset(offset) < nbComponents)
+		{
+			freeOffset(offset);
+		}
+	}
+
+	// Allocate space
+	offset = allocOffset(size, count, type);
+
+	// Fill
+	m_Meta[offset].Name = name;
+
+	// Store offset in map
+	m_MapName[name] = offset;
+
+	return offset;
+}
+
+/// Allocate specified number of components if necessary
+size_t CGPUProgramParams::allocOffset(uint size, uint count, TType type)
+{
+	uint nbComponents = size * count;
+
+	// Allocate space
+	size_t offset = m_Meta.size();
+	uint blocks = getNbRegistersByComponents(nbComponents); // per 4 components
+	m_Meta.resize(offset + blocks);
+	m_Vec.resize(offset + blocks);
+
+	// Fill
+	m_Meta[offset].Size = size;
+	m_Meta[offset].Count = count;
+	m_Meta[offset].Type = type;
+	m_Meta[offset].Prev = m_Last;
+	m_Meta[offset].Next = s_End;
+
+	// Link
+	if (m_Last == s_End)
+	{
+		m_First = m_Last = offset;
+	}
+	else
+	{
+		nlassert(m_Meta[m_Last].Next == s_End); // code error otherwise
+		m_Meta[m_Last].Next = offset;
+		m_Last = offset;
+	}
+
+	return offset;
+}
+
+/// Return offset for specified index
+size_t CGPUProgramParams::getOffset(uint index) const
+{
+	if (index >= m_Map.size())
+		return s_End;
+	return m_Map[index];
+}
+
+size_t CGPUProgramParams::getOffset(const std::string &name) const
+{
+	std::map<std::string, size_t>::const_iterator it = m_MapName.find(name);
+	if (it == m_MapName.end())
+		return s_End;
+	return it->second;
+}
+
+/// Remove by offset
+void CGPUProgramParams::freeOffset(size_t offset)
+{
+	uint index = getIndexByOffset(offset);
+	if (index != ~0)
+	{
+		if (m_Map.size() > index)
+		{
+			m_Map[index] = getEnd();
+		}
+	}
+	const std::string &name = getNameByOffset(offset);
+	if (!name.empty())
+	{
+		if (m_MapName.find(name) != m_MapName.end())
+		{
+			m_MapName.erase(name);
+		}
+	}
+	if (offset == m_Last)
+	{
+		nlassert(m_Meta[offset].Next == s_End);
+		m_Last = m_Meta[offset].Prev;
+	}
+	else
+	{
+		nlassert(m_Meta[offset].Next != s_End);		
+		m_Meta[m_Meta[offset].Next].Prev = m_Meta[offset].Prev;
+	}
+	if (offset == m_First)
+	{
+		nlassert(m_Meta[offset].Prev == s_End);
+		m_First = m_Meta[offset].Next;
+	}
+	else
+	{
+		nlassert(m_Meta[offset].Prev != s_End);
+		m_Meta[m_Meta[offset].Prev].Next = m_Meta[offset].Next;
+	}
+}
+
+} /* namespace NL3D */
+
+/* end of file */

code/nel/src/3d/landscape.cpp

@@ -574,7 +574,10 @@ void			CLandscape::setDriver(IDriver *drv)
 
 		// Does the driver support VertexShader???
 		// only if VP supported by GPU.
-		_VertexShaderOk= (_Driver->isVertexProgramSupported() && !_Driver->isVertexProgramEmulated());
+		_VertexShaderOk = (!_Driver->isVertexProgramEmulated() && (
+			_Driver->supportVertexProgram(CVertexProgram::nelvp)
+			// || _Driver->supportVertexProgram(CVertexProgram::glsl330v) // TODO_VP_GLSL
+			));
 
 
 		// Does the driver has sufficient requirements for Vegetable???
@@ -1195,18 +1198,31 @@ void			CLandscape::render(const CVector &refineCenter, const CVector &frontVecto
 	// If VertexShader enabled, setup VertexProgram Constants.
 	if (_VertexShaderOk)
 	{
+		bool uprogstate = driver->isUniformProgramState();
+		uint nbvp = uprogstate ? CLandscapeVBAllocator::MaxVertexProgram : 1;
+		for (uint i = 0; i < nbvp; ++i)
+		{
+			CVertexProgramLandscape *program = _TileVB.getVP(i);
+			if (program)
+			{
+				// activate the program to set the uniforms in the program state for all programs
+				// note: when uniforms are driver state, the indices must be the same across programs
+				_TileVB.activateVP(i);
+
 				// c[0..3] take the ModelViewProjection Matrix.
-		driver->setConstantMatrix(0, IDriver::ModelViewProjection, IDriver::Identity);
+				driver->setUniformMatrix(IDriver::VertexProgram, program->getUniformIndex(CProgramIndex::ModelViewProjection), IDriver::ModelViewProjection, IDriver::Identity);
 				// c[4] take useful constants.
-		driver->setConstant(4, 0, 1, 0.5f, 0);
+				driver->setUniform4f(IDriver::VertexProgram, program->idx().ProgramConstants0, 0, 1, 0.5f, 0);
 				// c[5] take RefineCenter
-		driver->setConstant(5, refineCenter);
+				driver->setUniform3f(IDriver::VertexProgram, program->idx().RefineCenter, refineCenter);
 				// c[6] take info for Geomorph trnasition to TileNear.
-		driver->setConstant(6, CLandscapeGlobals::TileDistFarSqr, CLandscapeGlobals::OOTileDistDeltaSqr, 0, 0);
+				driver->setUniform2f(IDriver::VertexProgram, program->idx().TileDist, CLandscapeGlobals::TileDistFarSqr, CLandscapeGlobals::OOTileDistDeltaSqr);
 				// c[10] take the fog vector.
-		driver->setConstantFog(10);
+				driver->setUniformFog(IDriver::VertexProgram, program->getUniformIndex(CProgramIndex::Fog));
 				// c[12] take the current landscape Center / delta Pos to apply
-		driver->setConstant(12, _PZBModelPosition);
+				driver->setUniform3f(IDriver::VertexProgram, program->idx().PZBModelPosition, _PZBModelPosition);
+			}
+		}
 	}
 
 

code/nel/src/3d/landscapevb_allocator.cpp

@@ -82,7 +82,10 @@ void			CLandscapeVBAllocator::updateDriver(IDriver *driver)
 		deleteVertexProgram();
 		// Then rebuild VB format, and VertexProgram, if needed.
 		// Do it only if VP supported by GPU.
-		setupVBFormatAndVertexProgram(_Driver->isVertexProgramSupported()  && !_Driver->isVertexProgramEmulated());
+		setupVBFormatAndVertexProgram(!_Driver->isVertexProgramEmulated() && (
+			_Driver->supportVertexProgram(CVertexProgram::nelvp)
+			// || _Driver->supportVertexProgram(CVertexProgram::glsl330v) // TODO_VP_GLSL
+			));
 
 		// must reallocate the VertexBuffer.
 		if( _NumVerticesAllocated>0 )
@@ -247,14 +250,23 @@ void			CLandscapeVBAllocator::activate(uint vpId)
 	nlassert(_Driver);
 	nlassert(!_BufferLocked);
 
+	activateVP(vpId);
+
+	_Driver->activeVertexBuffer(_VB);
+}
+
+
+// ***************************************************************************
+void			CLandscapeVBAllocator::activateVP(uint vpId)
+{
+	nlassert(_Driver);
+
 	// If enabled, activate Vertex program first.
 	if (_VertexProgram[vpId])
 	{
 		//nlinfo("\nSTARTVP\n%s\nENDVP\n", _VertexProgram[vpId]->getProgram().c_str());
 		nlverify(_Driver->activeVertexProgram(_VertexProgram[vpId]));
 	}
-
-	_Driver->activeVertexBuffer(_VB);
 }
 
 
@@ -516,12 +528,11 @@ const char* NL3D_LandscapeTileLightMapEndProgram=
 // ***************************************************************************
 void			CLandscapeVBAllocator::deleteVertexProgram()
 {
-	for(uint i=0;i<MaxVertexProgram;i++)
+	for (uint i = 0; i < MaxVertexProgram; ++i)
 	{
 		if (_VertexProgram[i])
 		{
-			delete _VertexProgram[i];
+			_VertexProgram[i] = NULL; // smartptr
-			_VertexProgram[i]= NULL;
 		}
 	}
 }
@@ -560,9 +571,8 @@ void			CLandscapeVBAllocator::setupVBFormatAndVertexProgram(bool withVertexProgr
 			_VB.initEx();
 
 			// Init the Vertex Program.
-			string	vpgram= string(NL3D_LandscapeCommonStartProgram) +
+			_VertexProgram[0] = new CVertexProgramLandscape(Far0);
-				string(NL3D_LandscapeFar0EndProgram);
+			nlverify(_Driver->compileVertexProgram(_VertexProgram[0]));
-			_VertexProgram[0]= new CVertexProgram(vpgram.c_str());
 		}
 		else if(_Type==Far1)
 		{
@@ -577,9 +587,8 @@ void			CLandscapeVBAllocator::setupVBFormatAndVertexProgram(bool withVertexProgr
 			_VB.initEx();
 
 			// Init the Vertex Program.
-			string	vpgram= string(NL3D_LandscapeCommonStartProgram) +
+			_VertexProgram[0] = new CVertexProgramLandscape(Far1);
-				string(NL3D_LandscapeFar1EndProgram);
+			nlverify(_Driver->compileVertexProgram(_VertexProgram[0]));
-			_VertexProgram[0]= new CVertexProgram(vpgram.c_str());
 		}
 		else
 		{
@@ -594,20 +603,76 @@ void			CLandscapeVBAllocator::setupVBFormatAndVertexProgram(bool withVertexProgr
 			_VB.initEx();
 
 			// Init the Vertex Program.
-			string	vpgram= string(NL3D_LandscapeCommonStartProgram) +
+			_VertexProgram[0] = new CVertexProgramLandscape(Tile, false);
-				string(NL3D_LandscapeTileEndProgram);
+			nlverify(_Driver->compileVertexProgram(_VertexProgram[0]));
-			_VertexProgram[0]= new CVertexProgram(vpgram.c_str());
 
 			// Init the Vertex Program for lightmap pass
-			vpgram= string(NL3D_LandscapeCommonStartProgram) +
+			_VertexProgram[1] = new CVertexProgramLandscape(Tile, true);
-				string(NL3D_LandscapeTileLightMapEndProgram);
+			nlverify(_Driver->compileVertexProgram(_VertexProgram[1]));
-			_VertexProgram[1]= new CVertexProgram(vpgram.c_str());
 		}
 	}
 
 }
 
 
+CVertexProgramLandscape::CVertexProgramLandscape(CLandscapeVBAllocator::TType type, bool lightMap)
+{
+	// nelvp
+	{
+		CSource *source = new CSource();
+		source->Profile = nelvp;
+		source->DisplayName = "Landscape/nelvp";
+		switch (type)
+		{
+		case CLandscapeVBAllocator::Far0:
+			source->DisplayName += "/far0";
+			source->setSource(std::string(NL3D_LandscapeCommonStartProgram) 
+				+ std::string(NL3D_LandscapeFar0EndProgram));
+			break;
+		case CLandscapeVBAllocator::Far1:
+			source->DisplayName += "/far1";
+			source->setSource(std::string(NL3D_LandscapeCommonStartProgram) 
+				+ std::string(NL3D_LandscapeFar1EndProgram));
+			break;
+		case CLandscapeVBAllocator::Tile:
+			source->DisplayName += "/tile";
+			if (lightMap)
+			{
+				source->DisplayName += "/lightmap";
+				source->setSource(std::string(NL3D_LandscapeCommonStartProgram) 
+					+ std::string(NL3D_LandscapeTileLightMapEndProgram));
+			}
+			else
+			{
+				source->setSource(std::string(NL3D_LandscapeCommonStartProgram) 
+					+ std::string(NL3D_LandscapeTileEndProgram));
+			}
+			break;
+		}
+		source->ParamIndices["modelViewProjection"] = 0;
+		source->ParamIndices["programConstants0"] = 4;
+		source->ParamIndices["refineCenter"] = 5;
+		source->ParamIndices["tileDist"] = 6;
+		source->ParamIndices["fog"] = 10;
+		source->ParamIndices["pzbModelPosition"] = 12;
+		addSource(source);
+	}
+	// TODO_VP_GLSL
+	{
+		// ....
+	}
+}
 
+void CVertexProgramLandscape::buildInfo()
+{
+	m_Idx.ProgramConstants0 = getUniformIndex("programConstants0");
+	nlassert(m_Idx.ProgramConstants0 != ~0);
+	m_Idx.RefineCenter = getUniformIndex("refineCenter");
+	nlassert(m_Idx.RefineCenter != ~0);
+	m_Idx.TileDist = getUniformIndex("tileDist");
+	nlassert(m_Idx.TileDist != ~0);
+	m_Idx.PZBModelPosition = getUniformIndex("pzbModelPosition");
+	nlassert(m_Idx.PZBModelPosition != ~0);
+}
 
 } // NL3D

code/nel/src/3d/lod_character_shape.cpp

@@ -264,9 +264,9 @@ void	CLodCharacterShapeBuild::compile(const std::vector<bool> &triangleSelection
 void	CLodCharacterShapeBuild::serial(NLMISC::IStream &f)
 {
 	// NEL_CLODBULD
-	f.serialCheck((uint32)'_LEN');
+	f.serialCheck(NELID("_LEN"));
-	f.serialCheck((uint32)'DOLC');
+	f.serialCheck(NELID("DOLC"));
-	f.serialCheck((uint32)'DLUB');
+	f.serialCheck(NELID("DLUB"));
 
 	/*
 	Version 1:
@@ -525,9 +525,9 @@ void			CLodCharacterShape::CBoneInfluence::serial(NLMISC::IStream &f)
 void			CLodCharacterShape::serial(NLMISC::IStream &f)
 {
 	// NEL_CLODSHAP
-	f.serialCheck((uint32)'_LEN');
+	f.serialCheck(NELID("_LEN"));
-	f.serialCheck((uint32)'DOLC');
+	f.serialCheck(NELID("DOLC"));
-	f.serialCheck((uint32)'PAHS');
+	f.serialCheck(NELID("PAHS"));
 
 	/*
 	Version 1:

code/nel/src/3d/material.cpp

@@ -18,7 +18,6 @@
 
 #include "nel/3d/material.h"
 #include "nel/3d/texture.h"
-#include "nel/3d/shader.h"
 #include "nel/3d/driver.h"
 #include "nel/misc/stream.h"
 

code/nel/src/3d/meshvp_per_pixel_light.cpp

@@ -32,14 +32,13 @@
 
 namespace NL3D
 {
-std::auto_ptr<CVertexProgram>	CMeshVPPerPixelLight::_VertexProgram[NumVp];
+
+NLMISC::CSmartPtr<CVertexProgramPerPixelLight>	CMeshVPPerPixelLight::_VertexProgram[NumVp];
 
 // ***************************************************************************
 // Light VP fragment constants start at 24
 static	const uint	VPLightConstantStart = 24;
 
-
-
 // ***************************************************************************
 // ***************************************************************************
 
@@ -355,18 +354,36 @@ static const char*	PPLightingVPCodeTest =
 ";
 ***************************************************************/
 
-
+class CVertexProgramPerPixelLight : public CVertexProgramLighted
-
-
-//=================================================================================
-void	CMeshVPPerPixelLight::initInstance(CMeshBaseInstance *mbi)
 {
-	// init the vertexProgram code.
+public:
-	static	bool	vpCreated= false;
+	struct CIdx
-	if(!vpCreated)
 	{
-		vpCreated= true;
+		/// Position or direction of strongest light
+		uint StrongestLight;
+		/// Viewer position
+		uint ViewerPos;
+	};
+	CVertexProgramPerPixelLight(uint vp);
+	virtual ~CVertexProgramPerPixelLight() { };
+	virtual void buildInfo();
+	const CIdx &idx() const { return m_Idx; }
 
+private:
+	CIdx m_Idx;
+
+};
+
+CVertexProgramPerPixelLight::CVertexProgramPerPixelLight(uint vp)
+{
+	// lighted settings
+	m_FeaturesLighted.SupportSpecular = (vp & 2) != 0;
+	m_FeaturesLighted.NumActivePointLights = MaxLight - 1;
+	m_FeaturesLighted.Normalize = false;
+	m_FeaturesLighted.CtStartNeLVP = VPLightConstantStart;
+
+	// nelvp
+	{
 		// Gives each vp name
 		// Bit 0 : 1 when it is a directionnal light
 		// Bit 1 : 1 when specular is needed
@@ -389,14 +406,17 @@ void	CMeshVPPerPixelLight::initInstance(CMeshBaseInstance *mbi)
 		};
 
 		uint numvp  = sizeof(vpName) / sizeof(const char *);
-		nlassert(NumVp == numvp); // make sure that it is in sync with header..todo : compile time assert :)
+		nlassert(CMeshVPPerPixelLight::NumVp == numvp); // make sure that it is in sync with header..todo : compile time assert :)
-		for (uint vp = 0; vp < NumVp; ++vp)
+
-		{
 		// \todo yoyo TODO_OPTIM Manage different number of pointLights
-			// NB: never call getLightVPFragment() with normalize, because already done by PerPixel fragment before.
+		// NB: never call getLightVPFragmentNeLVP() with normalize, because already done by PerPixel fragment before.
 		std::string vpCode	= std::string(vpName[vp])
 							  + std::string("# ***************") // temp for debug
-								  + CRenderTrav::getLightVPFragment(CRenderTrav::MaxVPLight-1, VPLightConstantStart, (vp & 2) != 0, false)
+							  + CRenderTrav::getLightVPFragmentNeLVP(
+									m_FeaturesLighted.NumActivePointLights, 
+									m_FeaturesLighted.CtStartNeLVP, 
+									m_FeaturesLighted.SupportSpecular,  
+									m_FeaturesLighted.Normalize)
 							  + std::string("# ***************") // temp for debug
 							  + std::string(PPLightingVPCodeEnd);
 		#ifdef NL_DEBUG
@@ -414,9 +434,61 @@ void	CMeshVPPerPixelLight::initInstance(CMeshBaseInstance *mbi)
 				nlassert(0);
 			}
 		#endif
-			_VertexProgram[vp]= std::auto_ptr<CVertexProgram>(new CVertexProgram(vpCode.c_str()));
+
+		CSource *source = new CSource();
+		source->DisplayName = NLMISC::toString("nelvp/MeshVPPerPixel/%i", vp);
+		source->Profile = CVertexProgram::nelvp;
+		source->setSource(vpCode);
+		source->ParamIndices["modelViewProjection"] = 0;
+		addSource(source);
 	}
 
+	// glsl
+	{
+		// TODO_VP_GLSL
+	}
+}
+
+void CVertexProgramPerPixelLight::buildInfo()
+{
+	CVertexProgramLighted::buildInfo();
+	if (profile() == nelvp)
+	{
+		m_Idx.StrongestLight = 4;
+		if (m_FeaturesLighted.SupportSpecular)
+		{
+			m_Idx.ViewerPos = 5;
+		}
+		else
+		{
+			m_Idx.ViewerPos = ~0;
+		}
+	}
+	else
+	{
+		// TODO_VP_GLSL
+	}
+	nlassert(m_Idx.StrongestLight != ~0);
+	if (m_FeaturesLighted.SupportSpecular)
+	{
+		nlassert(m_Idx.ViewerPos != ~0);
+	}
+}
+
+
+//=================================================================================
+void	CMeshVPPerPixelLight::initInstance(CMeshBaseInstance *mbi)
+{
+	// init the vertexProgram code.
+	static	bool	vpCreated= false;
+	if (!vpCreated)
+	{
+		vpCreated = true;
+		
+		for (uint vp = 0; vp < NumVp; ++vp)
+		{
+			_VertexProgram[vp] = new CVertexProgramPerPixelLight(vp);
+		}
 	}
 }
 
@@ -427,21 +499,24 @@ bool	CMeshVPPerPixelLight::begin(IDriver *drv,
 									const NLMISC::CVector &viewerPos)
 {
 	// test if supported by driver
-	if (!
+	if (drv->isVertexProgramEmulated()
-		 (drv->isVertexProgramSupported()
+		|| !drv->supportPerPixelLighting(SpecularLighting))
-		  && !drv->isVertexProgramEmulated()
-		  &&  drv->supportPerPixelLighting(SpecularLighting)
-		 )
-	   )
 	{
 		return false;
 	}
 	//
+	enable(true, drv); // must enable the vertex program before the vb is activated
+	CVertexProgramPerPixelLight *program = _ActiveVertexProgram;
+	if (!program)
+	{
+		// failed to compile vertex program
+		return false;
+	}
+	//
 	CRenderTrav		*renderTrav= &scene->getRenderTrav();
 	/// Setup for gouraud lighting
-	renderTrav->beginVPLightSetup(VPLightConstantStart,
+	renderTrav->prepareVPLightSetup();
-								  SpecularLighting,
+	renderTrav->beginVPLightSetup(program, invertedModelMat);
-								  invertedModelMat);
 	//
 	sint strongestLightIndex = renderTrav->getStrongestLightIndex();
 	if (strongestLightIndex == -1) return false; // if no strongest light, disable this vertex program
@@ -455,7 +530,7 @@ bool	CMeshVPPerPixelLight::begin(IDriver *drv,
 		{
 			// put light direction in object space
 			NLMISC::CVector lPos = invertedModelMat.mulVector(strongestLight.getDirection());
-			drv->setConstant(4, lPos);
+			drv->setUniform3f(IDriver::VertexProgram, program->idx().StrongestLight, lPos);
 			_IsPointLight = false;
 		}
 		break;
@@ -463,7 +538,7 @@ bool	CMeshVPPerPixelLight::begin(IDriver *drv,
 		{
 			// put light in object space
 			NLMISC::CVector lPos = invertedModelMat * strongestLight.getPosition();
-			drv->setConstant(4, lPos);
+			drv->setUniform3f(IDriver::VertexProgram, program->idx().StrongestLight, lPos);
 			_IsPointLight = true;
 		}
 		break;
@@ -477,14 +552,12 @@ bool	CMeshVPPerPixelLight::begin(IDriver *drv,
 	{
 		// viewer pos in object space
 		NLMISC::CVector vPos = invertedModelMat * viewerPos;
-		drv->setConstant(5, vPos);
+		drv->setUniform3f(IDriver::VertexProgram, program->idx().ViewerPos, vPos);
 	}
 
 	// c[0..3] take the ModelViewProjection Matrix. After setupModelMatrix();
-	drv->setConstantMatrix(0, IDriver::ModelViewProjection, IDriver::Identity);
+	drv->setUniformMatrix(IDriver::VertexProgram, program->getUniformIndex(CProgramIndex::ModelViewProjection), IDriver::ModelViewProjection, IDriver::Identity);
-	//
+
-	enable(true, drv); // must enable the vertex program before the vb is activated
-	//
 	return true;
 }
 
@@ -521,11 +594,19 @@ void	CMeshVPPerPixelLight::enable(bool enabled, IDriver *drv)
 						   | (SpecularLighting	      ? 2 : 0)
 						   | (_IsPointLight		      ? 1 : 0);
 			//
-			drv->activeVertexProgram(_VertexProgram[idVP].get());
+			if (drv->activeVertexProgram((CVertexProgramPerPixelLight *)_VertexProgram[idVP]))
+			{
+				_ActiveVertexProgram = _VertexProgram[idVP];
+			}
+			else
+			{
+				_ActiveVertexProgram = NULL;
+			}
 		}
 		else
 		{
 			drv->activeVertexProgram(NULL);
+			_ActiveVertexProgram = NULL;
 		}
 		_Enabled = enabled;
 	}
@@ -538,6 +619,8 @@ bool  CMeshVPPerPixelLight::setupForMaterial(const CMaterial &mat,
 											)
 {
 	bool enabled = (mat.getShader() == CMaterial::PerPixelLighting || mat.getShader() == CMaterial::PerPixelLightingNoSpec);
+	bool change = (enabled != _Enabled);
+	enable(enabled, drv); // enable disable the vertex program (for material that don't have the right shader)
 	if (enabled)
 	{
 		CRenderTrav		*renderTrav= &scene->getRenderTrav();
@@ -547,8 +630,6 @@ bool  CMeshVPPerPixelLight::setupForMaterial(const CMaterial &mat,
 		renderTrav->getStrongestLightColors(pplDiffuse, pplSpecular);
 		drv->setPerPixelLightingLight(pplDiffuse, pplSpecular, mat.getShininess());
 	}
-	bool change = (enabled != _Enabled);
-	enable(enabled, drv); // enable disable the vertex program (for material that don't have the right shader)
 	return change;
 }
 //=================================================================================

code/nel/src/3d/meshvp_wind_tree.cpp

@@ -39,7 +39,7 @@ static	const uint	VPLightConstantStart= 24;
 
 
 // ***************************************************************************
-std::auto_ptr<CVertexProgram>	CMeshVPWindTree::_VertexProgram[CMeshVPWindTree::NumVp];
+NLMISC::CSmartPtr<CVertexProgramWindTree> CMeshVPWindTree::_VertexProgram[CMeshVPWindTree::NumVp];
 
 static const char*	WindTreeVPCodeWave=
 "!!VP1.0																				\n\
@@ -79,6 +79,83 @@ static const char*	WindTreeVPCodeEnd=
 	END																					\n\
 ";
 
+
+class CVertexProgramWindTree : public CVertexProgramLighted
+{
+public:
+	struct CIdx
+	{
+		uint ProgramConstants[3];
+		uint WindLevel1;
+		uint WindLevel2[4];
+		uint WindLevel3[4];
+	};
+	CVertexProgramWindTree(uint numPls, bool specular, bool normalize);
+	virtual ~CVertexProgramWindTree() { };
+	virtual void buildInfo();
+	const CIdx &idx() const { return m_Idx; }
+
+	bool PerMeshSetup;
+
+private:
+	CIdx m_Idx;
+
+};
+
+CVertexProgramWindTree::CVertexProgramWindTree(uint numPls, bool specular, bool normalize)
+{
+	// lighted settings
+	m_FeaturesLighted.SupportSpecular = specular;
+	m_FeaturesLighted.NumActivePointLights = numPls;
+	m_FeaturesLighted.Normalize = normalize;
+	m_FeaturesLighted.CtStartNeLVP = VPLightConstantStart;
+
+	// constants cache
+	PerMeshSetup = false;
+
+	// nelvp
+	{
+		std::string vpCode = std::string(WindTreeVPCodeWave)
+			+ CRenderTrav::getLightVPFragmentNeLVP(numPls, VPLightConstantStart, specular, normalize)
+			+ WindTreeVPCodeEnd;
+
+		CSource *source = new CSource();
+		source->DisplayName = NLMISC::toString("nelvp/MeshVPWindTree/%i/%s/%s", numPls, specular ? "spec" : "nospec", normalize ? "normalize" : "nonormalize");
+		source->Profile = CVertexProgram::nelvp;
+		source->setSource(vpCode);
+		source->ParamIndices["modelViewProjection"] = 0;
+		source->ParamIndices["fog"] = 6;
+		addSource(source);
+	}
+
+	// TODO_VP_GLSL
+}
+
+void CVertexProgramWindTree::buildInfo()
+{
+	CVertexProgramLighted::buildInfo();
+	if (profile() == nelvp)
+	{
+		m_Idx.ProgramConstants[0] = 8;
+		m_Idx.ProgramConstants[1] = 9;
+		m_Idx.ProgramConstants[2] = 10;
+		m_Idx.WindLevel1 = 15;
+		m_Idx.WindLevel2[0] = 16;
+		m_Idx.WindLevel2[1] = 17;
+		m_Idx.WindLevel2[2] = 18;
+		m_Idx.WindLevel2[3] = 19;
+		m_Idx.WindLevel3[0] = 20;
+		m_Idx.WindLevel3[1] = 21;
+		m_Idx.WindLevel3[2] = 22;
+		m_Idx.WindLevel3[3] = 23;
+	}
+	else
+	{
+		// TODO_VP_GLSL
+	}
+}
+
+
 // ***************************************************************************
 float	CMeshVPWindTree::speedCos(float angle)
 {
@@ -130,21 +207,17 @@ void	CMeshVPWindTree::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
 	f.serial(SpecularLighting);
 }
 
-
+void CMeshVPWindTree::initVertexPrograms()
-// ***************************************************************************
-void	CMeshVPWindTree::initInstance(CMeshBaseInstance *mbi)
 {
 	// init the vertexProgram code.
 	static	bool	vpCreated= false;
+
 	if(!vpCreated)
 	{
 		vpCreated= true;
 		// All vpcode and begin() written for HrcDepth==3
 		nlassert(HrcDepth==3);
 
-		// combine fragments.
-		string	vpCode;
-
 		// For all possible VP.
 		for(uint i=0;i<NumVp;i++)
 		{
@@ -153,13 +226,16 @@ void	CMeshVPWindTree::initInstance(CMeshBaseInstance *mbi)
 			bool	normalize= (i&1)!=0;
 			bool	specular= (i&2)!=0;
 
-			// combine fragments
+			// combine
-			vpCode= string(WindTreeVPCodeWave)
+			_VertexProgram[i] = new CVertexProgramWindTree(numPls, normalize, specular);
-					+ CRenderTrav::getLightVPFragment(numPls, VPLightConstantStart, specular, normalize)
-					+ WindTreeVPCodeEnd;
-			_VertexProgram[i]= std::auto_ptr<CVertexProgram>(new CVertexProgram(vpCode.c_str()));
 		}
 	}
+}
+
+// ***************************************************************************
+void	CMeshVPWindTree::initInstance(CMeshBaseInstance *mbi)
+{
+	initVertexPrograms();
 
 	// init a random phase.
 	mbi->_VPWindTreePhase= frand(1);
@@ -203,21 +279,27 @@ inline void			CMeshVPWindTree::setupPerMesh(IDriver *driver, CScene *scene)
 		}
 	}
 
+	CVertexProgramWindTree *program = _ActiveVertexProgram;
+	nlassert(program);
+
 	// Setup common constants for each instances.
 	// c[8] take useful constants.
-	static	float	ct8[4]= {0, 1, 0.5f, 2};
+	driver->setUniform4f(IDriver::VertexProgram, program->idx().ProgramConstants[0], 
-	driver->setConstant(8, 1, ct8);
+		0, 1, 0.5f, 2);
 	// c[9] take other useful constants.
-	static	float	ct9[4]= {3.f, 0.f, -1.f, -2.f};
+	driver->setUniform4f(IDriver::VertexProgram, program->idx().ProgramConstants[1], 
-	driver->setConstant(9, 1, ct9);
+		3.f, 0.f, -1.f, -2.f);
 	// c[10] take Number of phase (4) for level2 and 3. -0.01 to avoid int value == 4.
-	static	float	ct10[4]= {4-0.01f, 0, 0, 0};
+	driver->setUniform4f(IDriver::VertexProgram, program->idx().ProgramConstants[2], 
-	driver->setConstant(10, 1, ct10);
+		4-0.01f, 0, 0, 0);
 }
 
 // ***************************************************************************
 inline	void		CMeshVPWindTree::setupPerInstanceConstants(IDriver *driver, CScene *scene, CMeshBaseInstance *mbi, const NLMISC::CMatrix &invertedModelMat)
 {
+	CVertexProgramWindTree *program = _ActiveVertexProgram;
+	nlassert(program);
+
 	// get instance info
 	float	instancePhase= mbi->_VPWindTreePhase;
 
@@ -238,16 +320,18 @@ inline	void		CMeshVPWindTree::setupPerInstanceConstants(IDriver *driver, CScene
 	setupLighting(scene, mbi, invertedModelMat);
 
 	// c[0..3] take the ModelViewProjection Matrix. After setupModelMatrix();
-	driver->setConstantMatrix(0, IDriver::ModelViewProjection, IDriver::Identity);
+	driver->setUniformMatrix(IDriver::VertexProgram, program->getUniformIndex(CProgramIndex::ModelViewProjection), 
+		IDriver::ModelViewProjection, IDriver::Identity);
 	// c[4..7] take the ModelView Matrix. After setupModelMatrix();00
-	driver->setConstantFog(6);
+	driver->setUniformFog(IDriver::VertexProgram, program->getUniformIndex(CProgramIndex::Fog));
 
 
 	// c[15] take Wind of level 0.
 	float	f;
 	f= _CurrentTime[0] + instancePhase;
 	f= speedCos(f) + Bias[0];
-	driver->setConstant(15, maxDeltaPosOS[0]*f );
+	driver->setUniform3f(IDriver::VertexProgram, program->idx().WindLevel1, 
+		maxDeltaPosOS[0]*f );
 
 
 	// c[16-19] take Wind of level 1.
@@ -255,16 +339,20 @@ inline	void		CMeshVPWindTree::setupPerInstanceConstants(IDriver *driver, CScene
 	float	instTime1= _CurrentTime[1] + instancePhase;
 	// phase 0.
 	f= speedCos( instTime1+0 ) + Bias[1];
-	driver->setConstant(16+0, maxDeltaPosOS[1]*f);
+	driver->setUniform3f(IDriver::VertexProgram, program->idx().WindLevel2[0], 
+		maxDeltaPosOS[1]*f);
 	// phase 1.
 	f= speedCos( instTime1+0.25f ) + Bias[1];
-	driver->setConstant(16+1, maxDeltaPosOS[1]*f);
+	driver->setUniform3f(IDriver::VertexProgram, program->idx().WindLevel2[1], 
+		maxDeltaPosOS[1]*f);
 	// phase 2.
 	f= speedCos( instTime1+0.50f ) + Bias[1];
-	driver->setConstant(16+2, maxDeltaPosOS[1]*f);
+	driver->setUniform3f(IDriver::VertexProgram, program->idx().WindLevel2[2], 
+		maxDeltaPosOS[1]*f);
 	// phase 3.
 	f= speedCos( instTime1+0.75f ) + Bias[1];
-	driver->setConstant(16+3, maxDeltaPosOS[1]*f);
+	driver->setUniform3f(IDriver::VertexProgram, program->idx().WindLevel2[3], 
+		maxDeltaPosOS[1]*f);
 
 
 	// c[20, 23] take Wind of level 2.
@@ -272,22 +360,54 @@ inline	void		CMeshVPWindTree::setupPerInstanceConstants(IDriver *driver, CScene
 	float	instTime2= _CurrentTime[2] + instancePhase;
 	// phase 0.
 	f= speedCos( instTime2+0 ) + Bias[2];
-	driver->setConstant(20+0, maxDeltaPosOS[2]*f);
+	driver->setUniform3f(IDriver::VertexProgram, program->idx().WindLevel3[0], 
+		maxDeltaPosOS[2]*f);
 	// phase 1.
 	f= speedCos( instTime2+0.25f ) + Bias[2];
-	driver->setConstant(20+1, maxDeltaPosOS[2]*f);
+	driver->setUniform3f(IDriver::VertexProgram, program->idx().WindLevel3[1], 
+		maxDeltaPosOS[2]*f);
 	// phase 2.
 	f= speedCos( instTime2+0.50f ) + Bias[2];
-	driver->setConstant(20+2, maxDeltaPosOS[2]*f);
+	driver->setUniform3f(IDriver::VertexProgram, program->idx().WindLevel3[2], 
+		maxDeltaPosOS[2]*f);
 	// phase 3.
 	f= speedCos( instTime2+0.75f ) + Bias[2];
-	driver->setConstant(20+3, maxDeltaPosOS[2]*f);
+	driver->setUniform3f(IDriver::VertexProgram, program->idx().WindLevel3[3], 
+		maxDeltaPosOS[2]*f);
 }
 
 // ***************************************************************************
 bool	CMeshVPWindTree::begin(IDriver *driver, CScene *scene, CMeshBaseInstance *mbi, const NLMISC::CMatrix &invertedModelMat, const NLMISC::CVector & /*viewerPos*/)
 {
-	if (!(driver->isVertexProgramSupported() && !driver->isVertexProgramEmulated())) return false;
+	if (driver->isVertexProgramEmulated()) return false;
+
+
+	// Activate the good VertexProgram
+	//===============
+
+	// Get how many pointLights are setuped now.
+	nlassert(scene != NULL);
+	CRenderTrav		*renderTrav= &scene->getRenderTrav();
+	renderTrav->prepareVPLightSetup();
+	sint	numPls= renderTrav->getNumVPLights()-1;
+	clamp(numPls, 0, CRenderTrav::MaxVPLight-1);
+
+
+	// Enable normalize only if requested by user. Because lighting don't manage correct "scale lighting"
+	uint	idVP= (SpecularLighting?2:0) + (driver->isForceNormalize()?1:0) ;
+	// correct VP id for correct unmber of pls.
+	idVP= numPls*4 + idVP;
+	// activate VP.
+	if (driver->activeVertexProgram(_VertexProgram[idVP]))
+	{
+		_ActiveVertexProgram = _VertexProgram[idVP];
+	}
+	else
+	{
+		// vertex program not supported
+		_ActiveVertexProgram = NULL;
+		return false;
+	}
 
 
 	// precompute mesh
@@ -296,22 +416,7 @@ bool	CMeshVPWindTree::begin(IDriver *driver, CScene *scene, CMeshBaseInstance *m
 	// Setup instance constants
 	setupPerInstanceConstants(driver, scene, mbi, invertedModelMat);
 
-	// Activate the good VertexProgram
-	//===============
 
-	// Get how many pointLights are setuped now.
-	nlassert(scene != NULL);
-	CRenderTrav		*renderTrav= &scene->getRenderTrav();
-	sint	numPls= renderTrav->getNumVPLights()-1;
-	clamp(numPls, 0, CRenderTrav::MaxVPLight-1);
-
-	// Enable normalize only if requested by user. Because lighting don't manage correct "scale lighting"
-	uint	idVP= (SpecularLighting?2:0) + (driver->isForceNormalize()?1:0) ;
-	// correct VP id for correct unmber of pls.
-	idVP= numPls*4 + idVP;
-
-	// activate VP.
-	driver->activeVertexProgram(_VertexProgram[idVP].get());
 
 
 	return true;
@@ -322,6 +427,7 @@ void	CMeshVPWindTree::end(IDriver *driver)
 {
 	// Disable the VertexProgram
 	driver->activeVertexProgram(NULL);
+	_ActiveVertexProgram = NULL;
 }
 
 // ***************************************************************************
@@ -347,7 +453,8 @@ void	CMeshVPWindTree::setupLighting(CScene *scene, CMeshBaseInstance *mbi, const
 	nlassert(scene != NULL);
 	CRenderTrav		*renderTrav= &scene->getRenderTrav();
 	// setup cte for lighting
-	renderTrav->beginVPLightSetup(VPLightConstantStart, SpecularLighting, invertedModelMat);
+	CVertexProgramWindTree *program = _ActiveVertexProgram;
+	renderTrav->beginVPLightSetup(program, invertedModelMat);
 }
 
 
@@ -367,33 +474,46 @@ bool	CMeshVPWindTree::supportMeshBlockRendering() const
 // ***************************************************************************
 bool	CMeshVPWindTree::isMBRVpOk(IDriver *driver) const
 {
-	return driver->isVertexProgramSupported() && !driver->isVertexProgramEmulated();
+	initVertexPrograms();
+
+	if (driver->isVertexProgramEmulated())
+	{
+		return false;
+	}
+	for (uint i = 0; i < NumVp; ++i)
+	{
+		if (!driver->compileVertexProgram(_VertexProgram[i]))
+		{
+			return false;
+		}
+	}
+	return true;
 }
 
 // ***************************************************************************
 void	CMeshVPWindTree::beginMBRMesh(IDriver *driver, CScene *scene)
 {
-	// precompute mesh
-	setupPerMesh(driver, scene);
-
 	/* Since need a VertexProgram Activation before activeVBHard, activate a default one
 		bet the common one will be "NoPointLight, NoSpecular, No ForceNormalize" => 0.
 	*/
 	_LastMBRIdVP = 0;
 
 	// activate VP.
-	driver->activeVertexProgram(_VertexProgram[_LastMBRIdVP].get());
+	driver->activeVertexProgram(_VertexProgram[_LastMBRIdVP]);
+	_ActiveVertexProgram = _VertexProgram[_LastMBRIdVP];
+
+	// precompute mesh
+	setupPerMesh(driver, scene);
+	_VertexProgram[_LastMBRIdVP]->PerMeshSetup = true;
 }
 
 // ***************************************************************************
 void	CMeshVPWindTree::beginMBRInstance(IDriver *driver, CScene *scene, CMeshBaseInstance *mbi, const NLMISC::CMatrix &invertedModelMat)
 {
-	// setup first constants for this instance
-	setupPerInstanceConstants(driver, scene, mbi, invertedModelMat);
-
 	// Get how many pointLights are setuped now.
 	nlassert(scene != NULL);
 	CRenderTrav		*renderTrav= &scene->getRenderTrav();
+	renderTrav->prepareVPLightSetup();
 	sint	numPls= renderTrav->getNumVPLights()-1;
 	clamp(numPls, 0, CRenderTrav::MaxVPLight-1);
 
@@ -406,15 +526,27 @@ void	CMeshVPWindTree::beginMBRInstance(IDriver *driver, CScene *scene, CMeshBase
 	if(idVP != _LastMBRIdVP)
 	{
 		_LastMBRIdVP= idVP;
-		driver->activeVertexProgram(_VertexProgram[_LastMBRIdVP].get());
+		driver->activeVertexProgram(_VertexProgram[_LastMBRIdVP]);
+		_ActiveVertexProgram = _VertexProgram[_LastMBRIdVP];
+
+		if (!_VertexProgram[_LastMBRIdVP]->PerMeshSetup)
+		{
+			// precompute mesh
+			setupPerMesh(driver, scene);
+			_VertexProgram[_LastMBRIdVP]->PerMeshSetup = true;
 		}
 	}
 
+	// setup first constants for this instance
+	setupPerInstanceConstants(driver, scene, mbi, invertedModelMat);
+}
+
 // ***************************************************************************
 void	CMeshVPWindTree::endMBRMesh(IDriver *driver)
 {
 	// Disable the VertexProgram
 	driver->activeVertexProgram(NULL);
+	_ActiveVertexProgram = NULL;
 }
 
 // ***************************************************************************

code/nel/src/3d/packed_world.cpp

@@ -152,7 +152,7 @@ void CPackedWorld::getZones(std::vector<TPackedZoneBaseSPtr> &zones)
 void CPackedWorld::serialZoneNames(NLMISC::IStream &f) throw(NLMISC::EStream)
 {
 	f.serialVersion(1);
-	f.serialCheck((uint32) 'OWPA');
+	f.serialCheck(NELID("OWPA"));
 	f.serialCont(ZoneNames);
 }
 

code/nel/src/3d/pixel_program.cpp

@@ -0,0 +1,49 @@
+/** \file pixel_program.cpp
+ * Pixel program definition
+ */
+
+/* Copyright, 2000, 2001 Nevrax Ltd.
+ *
+ * This file is part of NEVRAX NEL.
+ * NEVRAX NEL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+
+ * NEVRAX NEL is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with NEVRAX NEL; see the file COPYING. If not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ */
+
+#include "std3d.h"
+
+#include <nel/3d/pixel_program.h>
+
+#include <nel/3d/driver.h>
+
+namespace NL3D 
+{
+
+// ***************************************************************************
+
+CPixelProgram::CPixelProgram()
+{
+	
+}
+
+// ***************************************************************************
+
+CPixelProgram::~CPixelProgram ()
+{
+	
+}
+
+// ***************************************************************************
+
+} // NL3D

code/nel/src/3d/program.cpp

@@ -0,0 +1,117 @@
+/**
+ * \file program.cpp
+ * \brief IProgram
+ * \date 2013-09-07 15:00GMT
+ * \author Jan Boon (Kaetemi)
+ * IProgram
+ */
+
+/* 
+ * Copyright (C) 2013  by authors
+ * 
+ * This file is part of NL3D.
+ * NL3D is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * NL3D is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
+ * Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public
+ * License along with NL3D.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include <nel/misc/types_nl.h>
+#include <nel/3d/program.h>
+
+// STL includes
+
+// NeL includes
+// #include <nel/misc/debug.h>
+#include <nel/misc/string_mapper.h>
+
+// Project includes
+#include <nel/3d/driver.h>
+
+using namespace std;
+// using namespace NLMISC;
+
+namespace NL3D {
+
+// ***************************************************************************
+
+IProgramDrvInfos::IProgramDrvInfos(IDriver *drv, ItGPUPrgDrvInfoPtrList it)
+{
+	_Driver = drv;
+	_DriverIterator = it;
+}
+
+// ***************************************************************************
+
+IProgramDrvInfos::~IProgramDrvInfos ()
+{
+	_Driver->removeGPUPrgDrvInfoPtr(_DriverIterator);
+}
+
+// ***************************************************************************
+
+IProgram::IProgram()
+{
+	
+}
+
+// ***************************************************************************
+
+IProgram::~IProgram()
+{
+	// Must kill the drv mirror of this program.
+	m_DrvInfo.kill();
+}
+
+const char *CProgramIndex::Names[NUM_UNIFORMS] = 
+{
+	"modelView", 
+	"modelViewInverse", 
+	"modelViewTranspose", 
+	"modelViewInverseTranspose",
+
+	"projection", 
+	"projectionInverse", 
+	"projectionTranspose", 
+	"projectionInverseTranspose", 
+
+	"modelViewProjection", 
+	"modelViewProjectionInverse", 
+	"modelViewProjectionTranspose", 
+	"modelViewProjectionInverseTranspose", 
+
+	"fog", 
+};
+
+void IProgram::buildInfo(CSource *source)
+{
+	nlassert(!m_Source);
+
+	m_Source = source;
+
+	// Fill index cache
+	for (int i = 0; i < CProgramIndex::NUM_UNIFORMS; ++i)
+	{
+		m_Index.Indices[i] = getUniformIndex(m_Index.Names[i]);
+	}
+
+	buildInfo();
+}
+
+void IProgram::buildInfo()
+{
+	
+}
+
+} /* namespace NL3D */
+
+/* end of file */

code/nel/src/3d/ps_located.cpp

@@ -73,7 +73,7 @@ CPSLocated::CPSLocated() : /*_MaxNumFaces(0),*/
 						   _ParametricMotion(false),
 						   _TriggerOnDeath(false),
 						   _LastForever(true),
-						   _TriggerID((uint32) 'NONE'),
+						   _TriggerID(NELID("NONE")),
 						   _NonIntegrableForceNbRefs(0),
 						   _NumIntegrableForceWithDifferentBasis(0)
 {

code/nel/src/3d/ps_particle_basic.cpp

@@ -786,7 +786,7 @@ void CPSMultiTexturedParticle::setupMaterial(ITexture *primary, IDriver *driver,
 	/// if bump is used, the matrix must be setupped each time (not a material field)
 	if (!_ForceBasicCaps && isMultiTextureEnabled() && _MainOp  == EnvBumpMap)
 	{
-		if (driver->isTextureAddrModeSupported(CMaterial::OffsetTexture))
+		if (driver->supportTextureAddrMode(CMaterial::OffsetTexture))
 		{
 			CTextureBump *tb = dynamic_cast<CTextureBump *>((ITexture *) _Texture2);
 			if (tb != NULL)
@@ -858,7 +858,7 @@ void CPSMultiTexturedParticle::setupMaterial(ITexture *primary, IDriver *driver,
 		}
 		else
 		{
-			if (!_ForceBasicCaps && (driver->isTextureAddrModeSupported(CMaterial::OffsetTexture) || driver->supportEMBM())) // envbumpmap supported ?
+			if (!_ForceBasicCaps && (driver->supportTextureAddrMode(CMaterial::OffsetTexture) || driver->supportEMBM())) // envbumpmap supported ?
 			{
 				CTextureBump *tb = dynamic_cast<CTextureBump *>((ITexture *) _Texture2);
 				if (tb != NULL)
@@ -917,7 +917,7 @@ void	CPSMultiTexturedParticle::setupMultiTexEnv(TOperator op, ITexture *tex1, IT
 			mat.enableTexAddrMode(false);
 			break;
 		case EnvBumpMap:
-			if (drv.isTextureAddrModeSupported(CMaterial::OffsetTexture))
+			if (drv.supportTextureAddrMode(CMaterial::OffsetTexture))
 			{
 				mat.setTexture(0, tex2);
 				mat.setTexture(1, tex1);
@@ -1113,7 +1113,7 @@ void CPSMultiTexturedParticle::enumTexs(std::vector<NLMISC::CSmartPtr<ITexture>
 	NL_PS_FUNC(CPSMultiTexturedParticle_enumTexs)
 	if (_MainOp  == EnvBumpMap && !_ForceBasicCaps)
 	{
-		if (drv.isTextureAddrModeSupported(CMaterial::OffsetTexture) || drv.supportEMBM())
+		if (drv.supportTextureAddrMode(CMaterial::OffsetTexture) || drv.supportEMBM())
 		{
 			if (_Texture2) dest.push_back(_Texture2);
 		}
@@ -1132,7 +1132,7 @@ bool CPSMultiTexturedParticle::isAlternateTextureUsed(IDriver &driver) const
 	NL_PS_FUNC(CPSMultiTexturedParticle_isAlternateTextureUsed)
 	if (!isTouched() && areBasicCapsForcedLocal() == areBasicCapsForced()) return (_MultiTexState & AlternateTextureUsed) != 0;
 	if (_MainOp  != EnvBumpMap) return false;
-	return _ForceBasicCaps || (!driver.isTextureAddrModeSupported(CMaterial::OffsetTexture) && !driver.supportEMBM());
+	return _ForceBasicCaps || (!driver.supportTextureAddrMode(CMaterial::OffsetTexture) && !driver.supportEMBM());
 }
 
 } // NL3D

code/nel/src/3d/render_trav.cpp

@@ -760,15 +760,24 @@ void		CRenderTrav::changeLightSetup(CLightContribution	*lightContribution, bool
 // ***************************************************************************
 // ***************************************************************************
 
-
+void		CRenderTrav::prepareVPLightSetup()
-// ***************************************************************************
-void		CRenderTrav::beginVPLightSetup(uint ctStart, bool supportSpecular, const CMatrix &invObjectWM)
 {
-	uint	i;
 	nlassert(MaxVPLight==4);
 	_VPNumLights= min(_NumLightEnabled, (uint)MaxVPLight);
-	_VPCurrentCtStart= ctStart;
+	// Must force real light setup at least the first time, in changeVPLightSetupMaterial()
-	_VPSupportSpecular= supportSpecular;
+	_VPMaterialCacheDirty= true;
+}
+
+// ***************************************************************************
+void		CRenderTrav::beginVPLightSetup(CVertexProgramLighted *program, const CMatrix &invObjectWM)
+{
+	uint	i;
+	// nlassert(MaxVPLight==4);
+	// _VPNumLights= min(_NumLightEnabled, (uint)MaxVPLight);
+	// _VPCurrentCtStart= ctStart;
+	// _VPSupportSpecular= supportSpecular;
+	_VPCurrent = program;
+	bool supportSpecular = program->featuresLighted().SupportSpecular;
 
 	// Prepare Colors (to be multiplied by material)
 	//================
@@ -787,7 +796,10 @@ void		CRenderTrav::beginVPLightSetup(uint ctStart, bool supportSpecular, const C
 	for(; i<MaxVPLight; i++)
 	{
 		_VPLightDiffuse[i] = CRGBA::Black;
-		Driver->setConstant(_VPCurrentCtStart+1+i, 0.f, 0.f, 0.f, 0.f);
+		if (program->idxLighted().Diffuse[i] != ~0)
+		{
+			Driver->setUniform4f(IDriver::VertexProgram, program->idxLighted().Diffuse[i], 0.f, 0.f, 0.f, 0.f);
+		}
 	}
 	// Specular. _VPCurrentCtStart+5 to 8 (only if supportSpecular)
 	if(supportSpecular)
@@ -800,7 +812,10 @@ void		CRenderTrav::beginVPLightSetup(uint ctStart, bool supportSpecular, const C
 		for(; i<MaxVPLight; i++)
 		{
 			_VPLightSpecular[i]= CRGBA::Black;
-			Driver->setConstant(_VPCurrentCtStart+5+i, 0.f, 0.f, 0.f, 0.f);
+			if (program->idxLighted().Specular[i] != ~0)
+			{
+				Driver->setUniform4f(IDriver::VertexProgram, program->idxLighted().Specular[i], 0.f, 0.f, 0.f, 0.f);
+			}
 		}
 	}
 
@@ -816,16 +831,7 @@ void		CRenderTrav::beginVPLightSetup(uint ctStart, bool supportSpecular, const C
 	lightDir= invObjectWM.mulVector(_DriverLight[0].getDirection());
 	lightDir.normalize();
 	lightDir= -lightDir;
-	if(supportSpecular)
+	Driver->setUniform3f(IDriver::VertexProgram, program->idxLighted().DirOrPos[0], lightDir); // The sun is the same for every instance.
-	{
-		// Setup lightDir.
-		Driver->setConstant(_VPCurrentCtStart+9, lightDir);
-	}
-	else
-	{
-		// Setup lightDir. NB: no specular color!
-		Driver->setConstant(_VPCurrentCtStart+5, lightDir);
-	}
 
 
 	// Setup PointLights
@@ -834,14 +840,7 @@ void		CRenderTrav::beginVPLightSetup(uint ctStart, bool supportSpecular, const C
 	if (supportSpecular)
 	{
 		// Setup eye in objectSpace for localViewer
-		Driver->setConstant(_VPCurrentCtStart+11, eye);
+		Driver->setUniform3f(IDriver::VertexProgram, program->idxLighted().EyePosition, eye);
-		// Start at 12.
-		startPLPos= 12;
-	}
-	else
-	{
-		// Start at 6.
-		startPLPos= 6;
 	}
 	// For all pointLight enabled (other are black: don't matter)
 	for(i=1; i<_VPNumLights; i++)
@@ -849,7 +848,7 @@ void		CRenderTrav::beginVPLightSetup(uint ctStart, bool supportSpecular, const C
 		// Setup position of light.
 		CVector		lightPos;
 		lightPos = invObjectWM * _DriverLight[i].getPosition();
-		Driver->setConstant(_VPCurrentCtStart+startPLPos+(i-1), lightPos);
+		Driver->setUniform3f(IDriver::VertexProgram, program->idxLighted().DirOrPos[i], lightPos);
 	}
 
 
@@ -860,6 +859,9 @@ void		CRenderTrav::beginVPLightSetup(uint ctStart, bool supportSpecular, const C
 // ***************************************************************************
 void		CRenderTrav::changeVPLightSetupMaterial(const CMaterial &mat, bool excludeStrongest)
 {
+	CVertexProgramLighted *program = _VPCurrent;
+	nlassert(program);
+
 	// Must test if at least done one time.
 	if(!_VPMaterialCacheDirty)
 	{
@@ -869,7 +871,7 @@ void		CRenderTrav::changeVPLightSetupMaterial(const CMaterial &mat, bool exclude
 			_VPMaterialCacheDiffuse == mat.getDiffuse().getPacked() )
 		{
 			// Same Diffuse part, test if same specular if necessary
-			if( !_VPSupportSpecular ||
+			if( !program->featuresLighted().SupportSpecular ||
 				( _VPMaterialCacheSpecular == mat.getSpecular().getPacked() &&
 				  _VPMaterialCacheShininess == mat.getShininess() )  )
 			{
@@ -899,7 +901,7 @@ void		CRenderTrav::changeVPLightSetupMaterial(const CMaterial &mat, bool exclude
 	// setup Ambient + Emissive
 	color= _VPFinalAmbient * mat.getAmbient();
 	color+= mat.getEmissive();
-	Driver->setConstant(_VPCurrentCtStart+0, 1, &color.R);
+	Driver->setUniform4f(IDriver::VertexProgram, program->idxLighted().Ambient, color);
 
 
 	// is the strongest light is not excluded, its index should have been setup to _VPNumLights
@@ -908,7 +910,7 @@ void		CRenderTrav::changeVPLightSetupMaterial(const CMaterial &mat, bool exclude
 	for(i = 0; i < strongestLightIndex; ++i)
 	{
 		color= _VPLightDiffuse[i] * matDiff;
-		Driver->setConstant(_VPCurrentCtStart+1+i, 1, &color.R);
+		Driver->setUniform4f(IDriver::VertexProgram, program->idxLighted().Diffuse[i], color);
 	}
 
 
@@ -917,24 +919,24 @@ void		CRenderTrav::changeVPLightSetupMaterial(const CMaterial &mat, bool exclude
 		color= _VPLightDiffuse[i] * matDiff;
 		_StrongestLightDiffuse.set((uint8) (255.f * color.R), (uint8) (255.f * color.G), (uint8) (255.f * color.B), (uint8) (255.f * color.A));
 		// setup strongest light to black for the gouraud part
-		Driver->setConstant(_VPCurrentCtStart + 1 + i, 0.f, 0.f, 0.f, 0.f);
+		Driver->setUniform4f(IDriver::VertexProgram, program->idxLighted().Diffuse[i], 0.f, 0.f, 0.f, 0.f);
 		++i;
 		// setup other lights
 		for(; i < _VPNumLights; i++)
 		{
 			color= _VPLightDiffuse[i] * matDiff;
-			Driver->setConstant(_VPCurrentCtStart + 1 + i, 1, &color.R);
+			Driver->setUniform4f(IDriver::VertexProgram, program->idxLighted().Diffuse[i], color);
 		}
 	}
 
 	// setup Specular
-	if(_VPSupportSpecular)
+	if (program->featuresLighted().SupportSpecular)
 	{
 		for(i = 0; i < strongestLightIndex; ++i)
 		{
 			color= _VPLightSpecular[i] * matSpec;
 			color.A= specExp;
-			Driver->setConstant(_VPCurrentCtStart+5+i, 1, &color.R);
+			Driver->setUniform4f(IDriver::VertexProgram, program->idxLighted().Specular[i], color);
 		}
 
 		if (i != _VPNumLights)
@@ -943,14 +945,14 @@ void		CRenderTrav::changeVPLightSetupMaterial(const CMaterial &mat, bool exclude
 			_StrongestLightSpecular.set((uint8) (255.f * color.R), (uint8) (255.f * color.G), (uint8) (255.f * color.B), (uint8) (255.f * color.A));
 
 			// setup strongest light to black (for gouraud part)
-			Driver->setConstant(_VPCurrentCtStart + 5 + i, 0.f, 0.f, 0.f, 0.f);
+			Driver->setUniform4f(IDriver::VertexProgram, program->idxLighted().Specular[i], 0.f, 0.f, 0.f, 0.f);
 			++i;
 			// setup other lights
 			for(; i < _VPNumLights; i++)
 			{
 				color= _VPLightSpecular[i] * matSpec;
 				color.A= specExp;
-				Driver->setConstant(_VPCurrentCtStart + 5 + i, 1, &color.R);
+				Driver->setUniform4f(IDriver::VertexProgram, program->idxLighted().Specular[i], color);
 			}
 		}
 	}
@@ -959,10 +961,7 @@ void		CRenderTrav::changeVPLightSetupMaterial(const CMaterial &mat, bool exclude
 	static	float	alphaCte[4]= {0,0,1,0};
 	alphaCte[3]= matDiff.A;
 	// setup at good place
-	if(_VPSupportSpecular)
+	Driver->setUniform4fv(IDriver::VertexProgram, program->idxLighted().DiffuseAlpha, 1, alphaCte);
-			Driver->setConstant(_VPCurrentCtStart+10, 1, alphaCte);
-	else
-			Driver->setConstant(_VPCurrentCtStart+9, 1, alphaCte);
 }
 
 // ***************************************************************************
@@ -1071,9 +1070,9 @@ static const char*	LightingVPFragmentSpecular_Begin=
 																						\n\
 	# Compute vertex-to-eye vector normed.												\n\
 	ADD	R4, c[CTS+11], -R5;																\n\
-	DP3	R4.w, R4, R4;																	\n\
+	DP3	R1.w, R4, R4;																	\n\
-	RSQ	R4.w, R4.w;																		\n\
+	RSQ	R1.w, R1.w;																		\n\
-	MUL R4, R4, R4.w;																	\n\
+	MUL	R4, R4, R1.w;																	\n\
 																						\n\
 	# Diffuse-Specular Sun																\n\
 	# Compute R1= halfAngleVector= (lightDir+R4).normed().								\n\
@@ -1168,8 +1167,66 @@ static	void	strReplaceAll(string &strInOut, const string &tokenSrc, const string
 	}
 }
 
+void CVertexProgramLighted::buildInfo()
+{
+	CVertexProgram::buildInfo();
+	if (profile() == nelvp)
+	{
+		// Fixed uniform locations
+		m_IdxLighted.Ambient = m_FeaturesLighted.CtStartNeLVP + 0;
+		for (uint i = 0; i < MaxLight; ++i)
+		{
+			m_IdxLighted.Diffuse[i] = m_FeaturesLighted.CtStartNeLVP + 1 + i;
+		}
+		if (m_FeaturesLighted.SupportSpecular)
+		{
+			for (uint i = 0; i < MaxLight; ++i)
+			{
+				m_IdxLighted.Specular[i] = m_FeaturesLighted.CtStartNeLVP + 5 + i;
+			}
+			m_IdxLighted.DirOrPos[0] = 9;
+			for (uint i = 1; i < MaxLight; ++i)
+			{
+				m_IdxLighted.DirOrPos[i] = m_FeaturesLighted.CtStartNeLVP + (12 - 1) + i;
+			}
+			m_IdxLighted.DiffuseAlpha = m_FeaturesLighted.CtStartNeLVP + 10;
+			m_IdxLighted.EyePosition = m_FeaturesLighted.CtStartNeLVP + 11;
+		}
+		else
+		{
+			for (uint i = 0; i < MaxLight; ++i)
+			{
+				m_IdxLighted.Specular[i] = ~0;
+			}
+			for (uint i = 0; i < MaxLight; ++i)
+			{
+				m_IdxLighted.DirOrPos[i] = m_FeaturesLighted.CtStartNeLVP + 5 + i;
+			}
+			m_IdxLighted.DiffuseAlpha = m_FeaturesLighted.CtStartNeLVP + 9;
+			m_IdxLighted.EyePosition = ~0;
+		}
+	}
+	else
+	{
+		// Named uniform locations
+		// TODO_VP_GLSL
+		// m_IdxLighted.Ambient = getUniformIndex("ambient");
+		// etc
+	}
+
+	nlassert(m_IdxLighted.Diffuse[0] != ~0);
+	if (m_FeaturesLighted.SupportSpecular)
+	{
+		nlassert(m_IdxLighted.Specular[0] != ~0);
+		nlassert(m_IdxLighted.EyePosition != ~0);
+	}
+	nlassert(m_IdxLighted.DirOrPos[0] != ~0);
+	nlassert(m_IdxLighted.DiffuseAlpha != ~0);
+}
+
+// generates the lighting part of a vertex program, nelvp profile
 // ***************************************************************************
-std::string		CRenderTrav::getLightVPFragment(uint numActivePointLights, uint ctStart, bool supportSpecular, bool normalize)
+std::string		CRenderTrav::getLightVPFragmentNeLVP(uint numActivePointLights, uint ctStart, bool supportSpecular, bool normalize)
 {
 	string	ret;
 

code/nel/src/3d/scene.cpp

@@ -191,6 +191,8 @@ CScene::CScene(bool bSmallScene) : LightTrav(bSmallScene)
 	_WaterEnvMap = NULL;
 
 	_GlobalSystemTime= 0.0;
+
+	_RequestParticlesAnimate = false;
 }
 // ***************************************************************************
 void	CScene::release()
@@ -377,6 +379,13 @@ void	CScene::endPartRender()
 	// Reset profiling
 	_NextRenderProfile= false;
 
+	IDriver *drv = getDriver();
+	drv->activeVertexProgram(NULL);
+	drv->activePixelProgram(NULL);
+	drv->activeGeometryProgram(NULL);
+
+	// Ensure nothing animates on subsequent renders
+	_EllapsedTime = 0.f;
 
 	/*
 	uint64 total = PSStatsRegisterPSModelObserver +
@@ -614,7 +623,11 @@ void	CScene::renderPart(UScene::TRenderPart rp, bool	doHrcPass)
 		// loadBalance
 		LoadBalancingTrav.traverse();
 		//
+		if (_RequestParticlesAnimate)
+		{
 			_ParticleSystemManager.processAnimate(_EllapsedTime); // deals with permanently animated particle systems
+			_RequestParticlesAnimate = false;
+		}
 		// Light
 		LightTrav.traverse();
 	}
@@ -860,6 +873,9 @@ void CScene::animate( TGlobalAnimationTime atTime )
 
 	// Rendered part are invalidate
 	_RenderedPart = UScene::RenderNothing;
+
+	// Particles are animated later due to dependencies
+	_RequestParticlesAnimate = true;
 }
 
 
@@ -1561,6 +1577,8 @@ void CScene::renderOcclusionTestMeshs()
 	nlassert(RenderTrav.getDriver());
 	RenderTrav.getDriver()->setupViewport(RenderTrav.getViewport());
 	RenderTrav.getDriver()->activeVertexProgram(NULL);
+	RenderTrav.getDriver()->activePixelProgram(NULL);
+	RenderTrav.getDriver()->activeGeometryProgram(NULL);
 	IDriver::TPolygonMode oldPolygonMode = RenderTrav.getDriver()->getPolygonMode();
 	CMaterial m;
 	m.initUnlit();

code/nel/src/3d/scene_group.cpp

@@ -405,7 +405,7 @@ void CInstanceGroup::serial (NLMISC::IStream& f)
 	 * ***********************************************/
 
 	// Serial a header
-	f.serialCheck ((uint32)'TPRG');
+	f.serialCheck (NELID("TPRG"));
 
 	/*
 	Version 5:

code/nel/src/3d/shader.cpp

@@ -1,111 +0,0 @@
-// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
-// Copyright (C) 2010  Winch Gate Property Limited
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#include "std3d.h"
-
-#include "nel/3d/shader.h"
-#include "nel/3d/driver.h"
-#include "nel/misc/path.h"
-#include "nel/misc/file.h"
-
-using namespace std;
-using namespace NLMISC;
-
-namespace NL3D
-{
-
-// ***************************************************************************
-
-CShader::~CShader()
-{
-	// Must kill the drv mirror of this shader.
-	_DrvInfo.kill();
-}
-
-// ***************************************************************************
-
-CShader::CShader()
-{
-	_ShaderChanged = true;
-}
-
-// ***************************************************************************
-
-void CShader::setText (const char *text)
-{
-	_Text = text;
-	_ShaderChanged = true;
-}
-
-// ***************************************************************************
-
-void CShader::setName (const char *name)
-{
-	_Name = name;
-	_ShaderChanged = true;
-}
-
-// ***************************************************************************
-
-bool CShader::loadShaderFile (const char *filename)
-{
-	_Text = "";
-	// Lookup
-	string _filename = CPath::lookup(filename, false, true, true);
-	if (!_filename.empty())
-	{
-		// File length
-		uint size = CFile::getFileSize (_filename);
-		_Text.reserve (size+1);
-
-		try
-		{
-			CIFile file;
-			if (file.open (_filename))
-			{
-				// Read it
-				while (!file.eof ())
-				{
-					char line[512];
-					file.getline (line, 512);
-					_Text += line;
-				}
-
-				// Set the shader name
-				_Name = CFile::getFilename (filename);
-				return true;
-			}
-			else
-			{
-				nlwarning ("Can't open the file %s for reading", _filename.c_str());
-			}
-		}
-		catch (const Exception &e)
-		{
-			nlwarning ("Error while reading %s : %s", _filename.c_str(), e.what());
-		}
-	}
-	return false;
-}
-
-// ***************************************************************************
-
-IShaderDrvInfos::~IShaderDrvInfos()
-{
-	_Driver->removeShaderDrvInfoPtr(_DriverIterator);
-}
-
-} // NL3D

code/nel/src/3d/shadow_map_manager.cpp

@@ -249,6 +249,7 @@ void			CShadowMapManager::renderGenerate(CScene *scene)
 	garbageShadowTextures(scene);
 
 	IDriver *driverForShadowGeneration= scene->getRenderTrav().getAuxDriver();
+	CSmartPtr<NL3D::ITexture> previousRenderTarget = driverForShadowGeneration->getRenderTarget();
 
 	// Init
 	// ********
@@ -488,7 +489,7 @@ void			CShadowMapManager::renderGenerate(CScene *scene)
 	}
 
 	// Set default render target
-	driverForShadowGeneration->setRenderTarget (NULL);
+	driverForShadowGeneration->setRenderTarget (previousRenderTarget);
 
 	// Allow Writing on all.
 	driverForShadowGeneration->setColorMask(true, true, true, true);

code/nel/src/3d/shape.cpp

@@ -116,7 +116,7 @@ IShape*	CShapeStream::getShapePointer () const
 void CShapeStream::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
 {
 	// First, serial an header or checking if it is correct
-	f.serialCheck ((uint32)'PAHS');
+	f.serialCheck (NELID("PAHS"));
 
 	// Then, serial the shape
 	f.serialPolyPtr (_Shape);

code/nel/src/3d/skeleton_weight.cpp

@@ -60,7 +60,7 @@ void CSkeletonWeight::build (const TNodeArray& array)
 void CSkeletonWeight::serial (NLMISC::IStream& f)
 {
 	// Serial a header
-	f.serialCheck ((uint32)'TWKS');
+	f.serialCheck (NELID("TWKS"));
 
 	// Serial a version number
 	(void)f.serialVersion (0);

code/nel/src/3d/stereo_debugger.cpp

@@ -0,0 +1,463 @@
+/**
+ * \file stereo_debugger.cpp
+ * \brief CStereoDebugger
+ * \date 2013-07-03 20:17GMT
+ * \author Jan Boon (Kaetemi)
+ * CStereoDebugger
+ */
+
+/* 
+ * Copyright (C) 2013  by authors
+ * 
+ * This file is part of NL3D.
+ * NL3D is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * NL3D is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
+ * Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public
+ * License along with NL3D.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#if !FINAL_VERSION
+#include <nel/misc/types_nl.h>
+#include <nel/3d/stereo_debugger.h>
+
+// STL includes
+
+// NeL includes
+// #include <nel/misc/debug.h>
+
+// Project includes
+#include <nel/3d/u_camera.h>
+#include <nel/3d/u_driver.h>
+#include <nel/3d/material.h>
+#include <nel/3d/texture_bloom.h>
+#include <nel/3d/texture_user.h>
+#include <nel/3d/driver_user.h>
+#include <nel/3d/u_texture.h>
+
+using namespace std;
+// using namespace NLMISC;
+
+namespace NL3D {
+
+namespace {
+
+const char *a_arbfp1 =
+	"!!ARBfp1.0\n"
+	"PARAM c[1] = { { 1, 0, 0.5 } };\n"
+	"TEMP R0;\n"
+	"TEMP R1;\n"
+	"TEMP R2;\n"
+	"TEX R0, fragment.texcoord[0], texture[0], 2D;\n"
+	"TEX R1, fragment.texcoord[0], texture[1], 2D;\n"
+	"ADD R2, R0, -R1;\n"
+	"ADD R1, R0, R1;\n"
+	"MUL R1, R1, c[0].z;\n"
+	"ABS R2, R2;\n"
+	"CMP R2, -R2, c[0].x, c[0].y;\n"
+	"ADD_SAT R2.x, R2, R2.y;\n"
+	"ADD_SAT R2.x, R2, R2.z;\n"
+	"ADD_SAT R2.x, R2, R2.w;\n"
+	"ABS R2.x, R2;\n"
+	"CMP R2.x, -R2, c[0].y, c[0];\n"
+	"ABS R0.x, R2;\n"
+	"CMP R2.x, -R0, c[0].y, c[0];\n"
+	"MOV R0.xzw, R1;\n"
+	"MAD R0.y, R1, c[0].z, c[0].z;\n"
+	"CMP R0, -R2.x, R1, R0;\n"
+	"MAD R1.x, R0, c[0].z, c[0].z;\n"
+	"CMP result.color.x, -R2, R1, R0;\n"
+	"MOV result.color.yzw, R0;\n"
+	"END\n";
+
+const char *a_ps_2_0 = 
+	"ps_2_0\n"
+	// cgc version 3.1.0013, build date Apr 18 2012
+	// command line args: -profile ps_2_0
+	// source file: pp_stereo_debug.cg
+	//vendor NVIDIA Corporation
+	//version 3.1.0.13
+	//profile ps_2_0
+	//program pp_stereo_debug
+	//semantic pp_stereo_debug.cTex0 : TEX0
+	//semantic pp_stereo_debug.cTex1 : TEX1
+	//var float2 texCoord : $vin.TEXCOORD0 : TEX0 : 0 : 1
+	//var sampler2D cTex0 : TEX0 : texunit 0 : 1 : 1
+	//var sampler2D cTex1 : TEX1 : texunit 1 : 2 : 1
+	//var float4 oCol : $vout.COLOR : COL : 3 : 1
+	//const c[0] = 0 1 0.5
+	"dcl_2d s0\n"
+	"dcl_2d s1\n"
+	"def c0, 0.00000000, 1.00000000, 0.50000000, 0\n"
+	"dcl t0.xy\n"
+	"texld r1, t0, s1\n"
+	"texld r2, t0, s0\n"
+	"add r0, r2, -r1\n"
+	"add r1, r2, r1\n"
+	"mul r1, r1, c0.z\n"
+	"abs r0, r0\n"
+	"cmp r0, -r0, c0.x, c0.y\n"
+	"add_pp_sat r0.x, r0, r0.y\n"
+	"add_pp_sat r0.x, r0, r0.z\n"
+	"add_pp_sat r0.x, r0, r0.w\n"
+	"abs_pp r0.x, r0\n"
+	"cmp_pp r0.x, -r0, c0.y, c0\n"
+	"abs_pp r0.x, r0\n"
+	"mov r2.xzw, r1\n"
+	"mad r2.y, r1, c0.z, c0.z\n"
+	"cmp r2, -r0.x, r1, r2\n"
+	"mad r1.x, r2, c0.z, c0.z\n"
+	"mov r0.yzw, r2\n"
+	"cmp r0.x, -r0, r1, r2\n"
+	"mov oC0, r0\n";
+
+class CStereoDebuggerFactory : public IStereoDeviceFactory
+{
+public:
+	IStereoDisplay *createDevice() const
+	{
+		return new CStereoDebugger();
+	}
+};
+
+} /* anonymous namespace */
+
+CStereoDebugger::CStereoDebugger() : m_Driver(NULL), m_Stage(0), m_SubStage(0), m_LeftTexU(NULL), m_RightTexU(NULL), m_PixelProgram(NULL)
+{
+	
+}
+
+CStereoDebugger::~CStereoDebugger()
+{
+	releaseTextures();
+
+	if (!m_Mat.empty())
+	{
+		m_Driver->deleteMaterial(m_Mat);
+	}
+
+	delete m_PixelProgram;
+	m_PixelProgram = NULL;
+
+	m_Driver = NULL;
+}
+
+/// Sets driver and generates necessary render targets
+void CStereoDebugger::setDriver(NL3D::UDriver *driver)
+{
+	nlassert(!m_PixelProgram);
+	
+	m_Driver = driver;
+	NL3D::IDriver *drvInternal = (static_cast<CDriverUser *>(driver))->getDriver();
+
+	if (drvInternal->supportBloomEffect() && drvInternal->supportNonPowerOfTwoTextures())
+	{
+		m_PixelProgram = new CPixelProgram();
+		// arbfp1
+		{
+			IProgram::CSource *source = new IProgram::CSource();
+			source->Features.MaterialFlags = CProgramFeatures::TextureStages;
+			source->Profile = IProgram::arbfp1;
+			source->setSourcePtr(a_arbfp1);
+			m_PixelProgram->addSource(source);
+		}
+		// ps_2_0
+		{
+			IProgram::CSource *source = new IProgram::CSource();
+			source->Features.MaterialFlags = CProgramFeatures::TextureStages;
+			source->Profile = IProgram::ps_2_0;
+			source->setSourcePtr(a_ps_2_0);
+			m_PixelProgram->addSource(source);
+		}
+		if (!drvInternal->compilePixelProgram(m_PixelProgram))
+		{
+			nlwarning("No supported pixel program for stereo debugger");
+
+			delete m_PixelProgram;
+			m_PixelProgram = NULL;
+		}
+	}
+
+	if (m_PixelProgram)
+	{
+		initTextures();
+
+		m_Mat = m_Driver->createMaterial();
+		m_Mat.initUnlit();
+		m_Mat.setColor(CRGBA::White);
+		m_Mat.setBlend (false);
+		m_Mat.setAlphaTest (false);
+		NL3D::CMaterial *mat = m_Mat.getObjectPtr();
+		mat->setShader(NL3D::CMaterial::Normal);
+		mat->setBlendFunc(CMaterial::one, CMaterial::zero);
+		mat->setZWrite(false);
+		mat->setZFunc(CMaterial::always);
+		mat->setDoubleSided(true);
+
+		setTextures();		
+
+		m_QuadUV.V0 = CVector(0.f, 0.f, 0.5f);
+		m_QuadUV.V1 = CVector(1.f, 0.f, 0.5f);
+		m_QuadUV.V2 = CVector(1.f, 1.f, 0.5f);
+		m_QuadUV.V3 = CVector(0.f, 1.f, 0.5f);
+
+		m_QuadUV.Uv0 = CUV(0.f,  0.f);
+		m_QuadUV.Uv1 = CUV(1.f, 0.f);
+		m_QuadUV.Uv2 = CUV(1.f, 1.f);
+		m_QuadUV.Uv3 = CUV(0.f,  1.f);
+	}
+}
+
+void CStereoDebugger::releaseTextures()
+{
+	if (!m_Mat.empty())
+	{
+		m_Mat.getObjectPtr()->setTexture(0, NULL);
+		m_Mat.getObjectPtr()->setTexture(1, NULL);
+		m_Driver->deleteMaterial(m_Mat);
+	}
+
+	delete m_LeftTexU;
+	m_LeftTexU = NULL;
+	m_LeftTex = NULL; // CSmartPtr
+
+	delete m_RightTexU;
+	m_RightTexU = NULL;
+	m_RightTex = NULL; // CSmartPtr
+}
+
+void CStereoDebugger::initTextures()
+{
+	uint32 width, height;
+	m_Driver->getWindowSize(width, height);
+	NL3D::IDriver *drvInternal = (static_cast<CDriverUser *>(m_Driver))->getDriver();	
+
+	m_LeftTex = new CTextureBloom();
+	m_LeftTex->setRenderTarget(true);
+	m_LeftTex->setReleasable(false);
+	m_LeftTex->resize(width, height);
+	m_LeftTex->setFilterMode(ITexture::Linear, ITexture::LinearMipMapOff);
+	m_LeftTex->setWrapS(ITexture::Clamp);
+	m_LeftTex->setWrapT(ITexture::Clamp);
+	drvInternal->setupTexture(*m_LeftTex);
+	m_LeftTexU = new CTextureUser(m_LeftTex);
+	nlassert(!drvInternal->isTextureRectangle(m_LeftTex)); // not allowed
+
+	m_RightTex = new CTextureBloom();
+	m_RightTex->setRenderTarget(true);
+	m_RightTex->setReleasable(false);
+	m_RightTex->resize(width, height);
+	m_RightTex->setFilterMode(ITexture::Linear, ITexture::LinearMipMapOff);
+	m_RightTex->setWrapS(ITexture::Clamp);
+	m_RightTex->setWrapT(ITexture::Clamp);
+	drvInternal->setupTexture(*m_RightTex);
+	m_RightTexU = new CTextureUser(m_RightTex);
+	nlassert(!drvInternal->isTextureRectangle(m_RightTex)); // not allowed
+}
+
+void CStereoDebugger::setTextures()
+{
+	NL3D::CMaterial *mat = m_Mat.getObjectPtr();
+	mat->setTexture(0, m_LeftTex);
+	mat->setTexture(1, m_RightTex);
+}
+
+void CStereoDebugger::verifyTextures()
+{
+	if (m_Driver)
+	{
+		uint32 width, height;
+		m_Driver->getWindowSize(width, height);
+		if (m_LeftTex->getWidth() != width 
+			|| m_RightTex->getWidth() != width 
+			|| m_LeftTex->getHeight() != height 
+			|| m_RightTex->getHeight() != height)
+		{
+			nldebug("Rebuild textures");
+			releaseTextures();
+			initTextures();
+			setTextures();
+		}
+	}
+}
+
+/// Gets the required screen resolution for this device
+bool CStereoDebugger::getScreenResolution(uint &width, uint &height)
+{
+	return false;
+}
+
+/// Set latest camera position etcetera
+void CStereoDebugger::updateCamera(uint cid, const NL3D::UCamera *camera)
+{
+	m_Frustum[cid] = camera->getFrustum();
+}
+
+/// Get the frustum to use for clipping
+void CStereoDebugger::getClippingFrustum(uint cid, NL3D::UCamera *camera) const
+{
+	// do nothing
+}
+
+/// Is there a next pass
+bool CStereoDebugger::nextPass()
+{
+	if (m_Driver->getPolygonMode() == UDriver::Filled)
+	{
+		switch (m_Stage)
+		{
+		case 0:
+			++m_Stage;
+			m_SubStage = 0;
+			return true;
+		case 1:
+			++m_Stage;
+			m_SubStage = 0;
+			return true;
+		case 2:
+			++m_Stage;
+			m_SubStage = 0;
+			return true;
+		case 3:
+			m_Stage = 0;
+			m_SubStage = 0;
+			return false;
+		}
+	}
+	else
+	{
+		switch (m_Stage)
+		{
+		case 0:
+			++m_Stage;
+			m_SubStage = 0;
+			return true;
+		case 1:
+			m_Stage = 0;
+			m_SubStage = 0;
+			return false;
+		}
+	}
+	return false;
+}
+
+/// Gets the current viewport
+const NL3D::CViewport &CStereoDebugger::getCurrentViewport() const
+{
+	if (m_Stage % 2) return m_LeftViewport;
+	else return m_RightViewport;
+}
+
+/// Gets the current camera frustum
+const NL3D::CFrustum &CStereoDebugger::getCurrentFrustum(uint cid) const
+{
+	return m_Frustum[cid];
+}
+
+/// Gets the current camera frustum
+void CStereoDebugger::getCurrentFrustum(uint cid, NL3D::UCamera *camera) const
+{
+	// do nothing
+}
+
+/// Gets the current camera matrix
+void CStereoDebugger::getCurrentMatrix(uint cid, NL3D::UCamera *camera) const
+{
+	// do nothing
+}
+
+/// At the start of a new render target
+bool CStereoDebugger::wantClear()
+{
+	m_SubStage = 1;
+	return m_Stage != 3;
+}
+	
+/// The 3D scene
+bool CStereoDebugger::wantScene()
+{
+	m_SubStage = 2;
+	return m_Stage != 3;
+}
+
+/// Interface within the 3D scene
+bool CStereoDebugger::wantInterface3D()
+{
+	m_SubStage = 3;
+	return m_Stage == 3;
+}
+	
+/// 2D Interface
+bool CStereoDebugger::wantInterface2D()
+{
+	m_SubStage = 4;
+	return m_Stage == 3;
+}
+
+/// Returns true if a new render target was set, always fase if not using render targets
+bool CStereoDebugger::beginRenderTarget()
+{
+	if (m_Stage != 3 && m_Driver && (m_Driver->getPolygonMode() == UDriver::Filled))
+	{
+		if (m_Stage % 2) static_cast<CDriverUser *>(m_Driver)->setRenderTarget(*m_RightTexU, 0, 0, 0, 0);
+		else static_cast<CDriverUser *>(m_Driver)->setRenderTarget(*m_LeftTexU, 0, 0, 0, 0);
+		return true;
+	}
+	return false;
+}
+
+/// Returns true if a render target was fully drawn, always false if not using render targets
+bool CStereoDebugger::endRenderTarget()
+{
+	if (m_Stage != 3 && m_Driver && (m_Driver->getPolygonMode() == UDriver::Filled))
+	{
+		CTextureUser cu;
+		(static_cast<CDriverUser *>(m_Driver))->setRenderTarget(cu);
+		bool fogEnabled = m_Driver->fogEnabled();
+		m_Driver->enableFog(false);
+
+		m_Driver->setMatrixMode2D11();
+		CViewport vp = CViewport();
+		m_Driver->setViewport(vp);
+		uint32 width, height;
+		NL3D::IDriver *drvInternal = (static_cast<CDriverUser *>(m_Driver))->getDriver();
+		NL3D::CMaterial *mat = m_Mat.getObjectPtr();
+		mat->setTexture(0, m_LeftTex);
+		mat->setTexture(1, m_RightTex);
+		drvInternal->activePixelProgram(m_PixelProgram);
+
+		m_Driver->drawQuad(m_QuadUV, m_Mat);
+
+		drvInternal->activePixelProgram(NULL);
+		m_Driver->enableFog(fogEnabled);
+
+		return true;
+	}
+	return false;
+}
+
+void CStereoDebugger::listDevices(std::vector<CStereoDeviceInfo> &devicesOut)
+{
+	CStereoDeviceInfo devInfo;
+	devInfo.Factory = new CStereoDebuggerFactory();
+	devInfo.Library = CStereoDeviceInfo::NeL3D;
+	devInfo.Class = CStereoDeviceInfo::StereoDisplay;
+	devInfo.Manufacturer = "NeL";
+	devInfo.ProductName = "Stereo Debugger";
+	devInfo.Serial = "NL-3D-DEBUG";
+	devicesOut.push_back(devInfo);
+}
+
+} /* namespace NL3D */
+
+#endif /* #if !FINAL_VERSION */
+
+/* end of file */

code/nel/src/3d/stereo_display.cpp

@@ -0,0 +1,112 @@
+/**
+ * \file stereo_display.cpp
+ * \brief IStereoDisplay
+ * \date 2013-06-27 16:29GMT
+ * \author Jan Boon (Kaetemi)
+ * IStereoDisplay
+ */
+
+/* 
+ * Copyright (C) 2013  by authors
+ * 
+ * This file is part of NL3D.
+ * NL3D is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * NL3D is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
+ * Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public
+ * License along with NL3D.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include <nel/misc/types_nl.h>
+#include <nel/3d/stereo_display.h>
+
+// STL includes
+
+// NeL includes
+// #include <nel/misc/debug.h>
+
+// Project includes
+#include <nel/3d/stereo_ovr.h>
+#include <nel/3d/stereo_libvr.h>
+#include <nel/3d/stereo_debugger.h>
+
+using namespace std;
+// using namespace NLMISC;
+
+namespace NL3D {
+
+IStereoDisplay::IStereoDisplay()
+{
+	
+}
+
+IStereoDisplay::~IStereoDisplay()
+{
+	
+}
+
+const char *IStereoDisplay::getLibraryName(CStereoDeviceInfo::TStereoDeviceLibrary library)
+{
+	static const char *nel3dName = "NeL 3D";
+	static const char *ovrName = "Oculus SDK";
+	static const char *libvrName = "LibVR";
+	static const char *openhmdName = "OpenHMD";
+	switch (library)
+	{
+	case CStereoDeviceInfo::NeL3D:
+		return nel3dName;
+	case CStereoDeviceInfo::OVR:
+		return ovrName;
+	case CStereoDeviceInfo::LibVR:
+		return libvrName;
+	case CStereoDeviceInfo::OpenHMD:
+		return openhmdName;
+	}
+	nlerror("Invalid device library specified");
+	return "<InvalidDeviceLibrary>";
+}
+
+void IStereoDisplay::listDevices(std::vector<CStereoDeviceInfo> &devicesOut)
+{
+#ifdef HAVE_LIBOVR
+	CStereoOVR::listDevices(devicesOut);
+#endif
+#ifdef HAVE_LIBVR
+	CStereoLibVR::listDevices(devicesOut);
+#endif
+#if !FINAL_VERSION
+	CStereoDebugger::listDevices(devicesOut);
+#endif
+}
+
+IStereoDisplay *IStereoDisplay::createDevice(const CStereoDeviceInfo &deviceInfo)
+{
+	return deviceInfo.Factory->createDevice();
+}
+
+void IStereoDisplay::releaseUnusedLibraries()
+{
+#ifdef HAVE_LIBOVR
+	if (!CStereoOVR::isLibraryInUse())
+		CStereoOVR::releaseLibrary();
+#endif
+}
+
+void IStereoDisplay::releaseAllLibraries()
+{
+#ifdef HAVE_LIBOVR
+	CStereoOVR::releaseLibrary();
+#endif
+}
+
+} /* namespace NL3D */
+
+/* end of file */

code/nel/src/3d/stereo_hmd.cpp

@@ -0,0 +1,55 @@
+/**
+ * \file stereo_hmd.cpp
+ * \brief IStereoHMD
+ * \date 2013-06-27 16:30GMT
+ * \author Jan Boon (Kaetemi)
+ * IStereoHMD
+ */
+
+/* 
+ * Copyright (C) 2013  by authors
+ * 
+ * This file is part of NL3D.
+ * NL3D is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * NL3D is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
+ * Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public
+ * License along with NL3D.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include <nel/misc/types_nl.h>
+#include <nel/3d/stereo_hmd.h>
+
+// STL includes
+
+// NeL includes
+// #include <nel/misc/debug.h>
+
+// Project includes
+
+using namespace std;
+// using namespace NLMISC;
+
+namespace NL3D {
+
+IStereoHMD::IStereoHMD()
+{
+	
+}
+
+IStereoHMD::~IStereoHMD()
+{
+	
+}
+
+} /* namespace NL3D */
+
+/* end of file */

code/nel/src/3d/stereo_libvr.cpp

@@ -0,0 +1,642 @@
+/**
+ * \file stereo_libvr.cpp
+ * \brief CStereoLibVR
+ * \date 2013-08-19 19:17MT
+ * \author Thibaut Girka (ThibG)
+ * CStereoLibVR
+ */
+
+/* 
+ * Copyright (C) 2013  by authors
+ * 
+ * This file is part of NL3D.
+ * NL3D is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * NL3D is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
+ * Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public
+ * License along with NL3D.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_LIBVR
+
+#include <nel/misc/types_nl.h>
+#include <nel/misc/time_nl.h>
+#include <nel/3d/stereo_libvr.h>
+
+// STL includes
+#include <sstream>
+
+// External includes
+extern "C" {
+#include <hmd.h>
+}
+
+// NeL includes
+// #include <nel/misc/debug.h>
+#include <nel/3d/u_camera.h>
+#include <nel/3d/u_driver.h>
+#include <nel/3d/material.h>
+#include <nel/3d/texture_bloom.h>
+#include <nel/3d/texture_user.h>
+#include <nel/3d/driver_user.h>
+#include <nel/3d/u_texture.h>
+
+// Project includes
+
+using namespace std;
+// using namespace NLMISC;
+
+namespace NL3D {
+
+extern const char *g_StereoOVR_fp40; //TODO: what?
+extern const char *g_StereoOVR_arbfp1; //TODO: what?
+extern const char *g_StereoOVR_ps_2_0; //TODO: what?
+
+namespace {
+sint s_DeviceCounter = 0;
+};
+
+class CStereoLibVRDeviceHandle : public IStereoDeviceFactory
+{
+public:
+	// fixme: virtual destructor???
+	IStereoDisplay *createDevice() const
+	{
+		CStereoLibVR *stereo = new CStereoLibVR(this);
+		if (stereo->isDeviceCreated())
+			return stereo;
+		delete stereo;
+		return NULL;
+	}
+};
+
+class CStereoLibVRDevicePtr
+{
+public:
+    struct hmd *HMDDevice;
+    struct display_info HMDInfo;
+    float InterpupillaryDistance;
+};
+
+CStereoLibVR::CStereoLibVR(const CStereoLibVRDeviceHandle *handle) : m_Stage(0), m_SubStage(0), m_OrientationCached(false), m_Driver(NULL), m_BarrelTexU(NULL), m_PixelProgram(NULL), m_EyePosition(0.0f, 0.09f, 0.15f), m_Scale(1.0f)
+{
+	struct stereo_config st_conf;
+
+	++s_DeviceCounter;
+	// For now, LibVR doesn't support multiple devices...
+	m_DevicePtr = new CStereoLibVRDevicePtr();
+	m_DevicePtr->HMDDevice = hmd_open_first(0);
+	m_DevicePtr->InterpupillaryDistance = 0.0647; //TODO
+
+	if (m_DevicePtr->HMDDevice)
+	{
+		hmd_get_display_info(m_DevicePtr->HMDDevice, &m_DevicePtr->HMDInfo);
+		hmd_get_stereo_config(m_DevicePtr->HMDDevice, &st_conf);
+		nldebug("LibVR: HScreenSize: %f, VScreenSize: %f", m_DevicePtr->HMDInfo.h_screen_size, m_DevicePtr->HMDInfo.v_screen_size);
+		nldebug("LibVR: VScreenCenter: %f", m_DevicePtr->HMDInfo.v_center);
+		nldebug("LibVR: EyeToScreenDistance: %f", m_DevicePtr->HMDInfo.eye_to_screen[0]);
+		nldebug("LibVR: LensSeparationDistance: %f", m_DevicePtr->HMDInfo.lens_separation);
+		nldebug("LibVR: HResolution: %i, VResolution: %i", m_DevicePtr->HMDInfo.h_resolution, m_DevicePtr->HMDInfo.v_resolution);
+		nldebug("LibVR: DistortionK[0]: %f, DistortionK[1]: %f", m_DevicePtr->HMDInfo.distortion_k[0], m_DevicePtr->HMDInfo.distortion_k[1]);
+		nldebug("LibVR: DistortionK[2]: %f, DistortionK[3]: %f", m_DevicePtr->HMDInfo.distortion_k[2], m_DevicePtr->HMDInfo.distortion_k[3]);
+		nldebug("LibVR: Scale: %f", st_conf.distort.scale);
+		m_LeftViewport.init(0.f, 0.f, 0.5f, 1.0f);
+		m_RightViewport.init(0.5f, 0.f, 0.5f, 1.0f);
+	}
+}
+
+CStereoLibVR::~CStereoLibVR()
+{
+	if (!m_BarrelMat.empty())
+	{
+		m_BarrelMat.getObjectPtr()->setTexture(0, NULL);
+		m_Driver->deleteMaterial(m_BarrelMat);
+	}
+	delete m_BarrelTexU;
+	m_BarrelTexU = NULL;
+	m_BarrelTex = NULL; // CSmartPtr
+
+	delete m_PixelProgram;
+	m_PixelProgram = NULL;
+
+	m_Driver = NULL;
+
+	if (m_DevicePtr->HMDDevice)
+		hmd_close(m_DevicePtr->HMDDevice);
+
+	delete m_DevicePtr;
+	m_DevicePtr = NULL;
+
+	--s_DeviceCounter;
+}
+
+void CStereoLibVR::setDriver(NL3D::UDriver *driver)
+{
+	nlassert(!m_PixelProgram);
+
+	NL3D::IDriver *drvInternal = (static_cast<CDriverUser *>(driver))->getDriver();	
+	if (drvInternal->supportPixelProgram(CPixelProgram::fp40) && drvInternal->supportBloomEffect() && drvInternal->supportNonPowerOfTwoTextures())
+	{
+		nldebug("VR: fp40");
+		m_PixelProgram = new CPixelProgram(g_StereoOVR_fp40);		
+	}
+	else if (drvInternal->supportPixelProgram(CPixelProgram::arbfp1) && drvInternal->supportBloomEffect() && drvInternal->supportNonPowerOfTwoTextures())
+	{
+		nldebug("VR: arbfp1");
+		m_PixelProgram = new CPixelProgram(g_StereoOVR_arbfp1);		
+	}
+	else if (drvInternal->supportPixelProgram(CPixelProgram::ps_2_0))
+	{
+		nldebug("VR: ps_2_0");
+		m_PixelProgram = new CPixelProgram(g_StereoOVR_ps_2_0);	
+	}
+
+	if (m_PixelProgram)
+	{
+		m_Driver = driver;
+
+		m_BarrelTex = new CTextureBloom(); // lol bloom
+		m_BarrelTex->setRenderTarget(true);
+		m_BarrelTex->setReleasable(false);
+		m_BarrelTex->resize(m_DevicePtr->HMDInfo.h_resolution, m_DevicePtr->HMDInfo.v_resolution);
+		m_BarrelTex->setFilterMode(ITexture::Linear, ITexture::LinearMipMapOff);
+		m_BarrelTex->setWrapS(ITexture::Clamp);
+		m_BarrelTex->setWrapT(ITexture::Clamp);
+		drvInternal->setupTexture(*m_BarrelTex);
+		m_BarrelTexU = new CTextureUser(m_BarrelTex);
+
+		m_BarrelMat = m_Driver->createMaterial();
+		m_BarrelMat.initUnlit();
+		m_BarrelMat.setColor(CRGBA::White);
+		m_BarrelMat.setBlend (false);
+		m_BarrelMat.setAlphaTest (false);
+		NL3D::CMaterial *barrelMat = m_BarrelMat.getObjectPtr();
+		barrelMat->setShader(NL3D::CMaterial::PostProcessing);
+		barrelMat->setBlendFunc(CMaterial::one, CMaterial::zero);
+		barrelMat->setZWrite(false);
+		barrelMat->setZFunc(CMaterial::always);
+		barrelMat->setDoubleSided(true);
+		barrelMat->setTexture(0, m_BarrelTex);
+
+		m_BarrelQuadLeft.V0 = CVector(0.f, 0.f, 0.5f);
+		m_BarrelQuadLeft.V1 = CVector(0.5f, 0.f, 0.5f);
+		m_BarrelQuadLeft.V2 = CVector(0.5f, 1.f, 0.5f);
+		m_BarrelQuadLeft.V3 = CVector(0.f, 1.f, 0.5f);
+
+		m_BarrelQuadRight.V0 = CVector(0.5f, 0.f, 0.5f);
+		m_BarrelQuadRight.V1 = CVector(1.f, 0.f, 0.5f);
+		m_BarrelQuadRight.V2 = CVector(1.f, 1.f, 0.5f);
+		m_BarrelQuadRight.V3 = CVector(0.5f, 1.f, 0.5f);
+
+		nlassert(!drvInternal->isTextureRectangle(m_BarrelTex)); // not allowed
+
+		m_BarrelQuadLeft.Uv0 = CUV(0.f,  0.f);
+		m_BarrelQuadLeft.Uv1 = CUV(0.5f, 0.f);
+		m_BarrelQuadLeft.Uv2 = CUV(0.5f, 1.f);
+		m_BarrelQuadLeft.Uv3 = CUV(0.f,  1.f);
+
+		m_BarrelQuadRight.Uv0 = CUV(0.5f,  0.f);
+		m_BarrelQuadRight.Uv1 = CUV(1.f, 0.f);
+		m_BarrelQuadRight.Uv2 = CUV(1.f, 1.f);
+		m_BarrelQuadRight.Uv3 = CUV(0.5f, 1.f);
+	}
+	else
+	{
+		nlwarning("VR: No pixel program support");
+	}
+}
+
+bool CStereoLibVR::getScreenResolution(uint &width, uint &height)
+{
+	width = m_DevicePtr->HMDInfo.h_resolution;
+	height = m_DevicePtr->HMDInfo.v_resolution;
+	return true;
+}
+
+void CStereoLibVR::initCamera(uint cid, const NL3D::UCamera *camera)
+{
+	struct stereo_config st_conf;
+	hmd_get_stereo_config(m_DevicePtr->HMDDevice, &st_conf);
+
+	float ar = st_conf.proj.aspect_ratio;
+	float fov = st_conf.proj.yfov;
+	m_LeftFrustum[cid].initPerspective(fov, ar, camera->getFrustum().Near, camera->getFrustum().Far);
+	m_RightFrustum[cid] = m_LeftFrustum[cid];
+
+	float projectionCenterOffset = st_conf.proj.projection_offset * 0.5 * (m_LeftFrustum[cid].Right - m_LeftFrustum[cid].Left);
+	nldebug("LibVR: projectionCenterOffset = %f", projectionCenterOffset);
+
+	m_LeftFrustum[cid].Left -= projectionCenterOffset;
+	m_LeftFrustum[cid].Right -= projectionCenterOffset;
+	m_RightFrustum[cid].Left += projectionCenterOffset;
+	m_RightFrustum[cid].Right += projectionCenterOffset;
+
+	// TODO: Clipping frustum should also take into account the IPD
+	m_ClippingFrustum[cid] = m_LeftFrustum[cid];
+	m_ClippingFrustum[cid].Left = min(m_LeftFrustum[cid].Left, m_RightFrustum[cid].Left);
+	m_ClippingFrustum[cid].Right = max(m_LeftFrustum[cid].Right, m_RightFrustum[cid].Right);
+}
+
+/// Get the frustum to use for clipping
+void CStereoLibVR::getClippingFrustum(uint cid, NL3D::UCamera *camera) const
+{
+	camera->setFrustum(m_ClippingFrustum[cid]);
+}
+
+void CStereoLibVR::updateCamera(uint cid, const NL3D::UCamera *camera)
+{
+	if (camera->getFrustum().Near != m_LeftFrustum[cid].Near
+		|| camera->getFrustum().Far != m_LeftFrustum[cid].Far)
+		CStereoLibVR::initCamera(cid, camera);
+	m_CameraMatrix[cid] = camera->getMatrix();
+}
+
+bool CStereoLibVR::nextPass()
+{
+	// Do not allow weird stuff.
+	uint32 width, height;
+	m_Driver->getWindowSize(width, height);
+	nlassert(width == m_DevicePtr->HMDInfo.h_resolution);
+	nlassert(height == m_DevicePtr->HMDInfo.v_resolution);
+
+	if (m_Driver->getPolygonMode() == UDriver::Filled)
+	{
+		switch (m_Stage)
+		{
+		case 0:
+			++m_Stage;
+			m_SubStage = 0;
+			// stage 1:
+			// (initBloom)
+			// clear buffer
+			// draw scene left
+			return true;
+		case 1:
+			++m_Stage;
+			m_SubStage = 0;
+			// stage 2:
+			// draw scene right
+			return true;
+		case 2:
+			++m_Stage;
+			m_SubStage = 0;
+			// stage 3:
+			// (endBloom)
+			// draw interface 3d left
+			return true;
+		case 3:
+			++m_Stage;
+			m_SubStage = 0;
+			// stage 4:
+			// draw interface 3d right
+			return true;
+		case 4:
+			++m_Stage;
+			m_SubStage = 0;
+			// stage 5:
+			// (endInterfacesDisplayBloom)
+			// draw interface 2d left
+			return true;
+		case 5:
+			++m_Stage;
+			m_SubStage = 0;
+			// stage 6:
+			// draw interface 2d right
+			return true;
+		case 6:
+			m_Stage = 0;
+			m_SubStage = 0;
+			// present
+			m_OrientationCached = false;
+			return false;
+		}
+	}
+	else
+	{
+		switch (m_Stage)
+		{
+		case 0:
+			++m_Stage;
+			m_SubStage = 0;
+			return true;
+		case 1:
+			m_Stage = 0;
+			m_SubStage = 0;
+			return false;
+		}
+	}
+	nlerror("Invalid stage");
+	m_Stage = 0;
+	m_SubStage = 0;
+	m_OrientationCached = false;
+	return false;
+}
+
+const NL3D::CViewport &CStereoLibVR::getCurrentViewport() const
+{
+	if (m_Stage % 2) return m_LeftViewport;
+	else return m_RightViewport;
+}
+
+const NL3D::CFrustum &CStereoLibVR::getCurrentFrustum(uint cid) const
+{
+	if (m_Stage % 2) return m_LeftFrustum[cid];
+	else return m_RightFrustum[cid];
+}
+
+void CStereoLibVR::getCurrentFrustum(uint cid, NL3D::UCamera *camera) const
+{
+	if (m_Stage % 2) camera->setFrustum(m_LeftFrustum[cid]);
+	else camera->setFrustum(m_RightFrustum[cid]);
+}
+
+void CStereoLibVR::getCurrentMatrix(uint cid, NL3D::UCamera *camera) const
+{
+	CMatrix translate;
+	if (m_Stage % 2) translate.translate(CVector((m_DevicePtr->InterpupillaryDistance * m_Scale) * -0.5f, 0.f, 0.f));
+	else translate.translate(CVector((m_DevicePtr->InterpupillaryDistance * m_Scale) * 0.5f, 0.f, 0.f));
+	CMatrix mat = m_CameraMatrix[cid] * translate;
+	if (camera->getTransformMode() == NL3D::UTransformable::RotQuat)
+	{
+		camera->setPos(mat.getPos());
+		camera->setRotQuat(mat.getRot());
+	}
+	else
+	{
+		// camera->setTransformMode(NL3D::UTransformable::DirectMatrix);
+		camera->setMatrix(mat);
+	}
+}
+
+bool CStereoLibVR::wantClear()
+{
+	switch (m_Stage)
+	{
+	case 1:
+		m_SubStage = 1;
+		return true;
+	}
+	return m_Driver->getPolygonMode() != UDriver::Filled;
+}
+	
+bool CStereoLibVR::wantScene()
+{
+	switch (m_Stage)
+	{
+	case 1:
+	case 2:
+		m_SubStage = 2;
+		return true;
+	}
+	return m_Driver->getPolygonMode() != UDriver::Filled;
+}
+
+bool CStereoLibVR::wantInterface3D()
+{
+	switch (m_Stage)
+	{
+	case 3:
+	case 4:
+		m_SubStage = 3;
+		return true;
+	}
+	return m_Driver->getPolygonMode() != UDriver::Filled;
+}
+
+bool CStereoLibVR::wantInterface2D()
+{
+	switch (m_Stage)
+	{
+	case 5:
+	case 6:
+		m_SubStage = 4;
+		return true;
+	}
+	return m_Driver->getPolygonMode() != UDriver::Filled;
+}
+
+
+/// Returns non-NULL if a new render target was set
+bool CStereoLibVR::beginRenderTarget()
+{
+	// render target always set before driver clear
+	// nlassert(m_SubStage <= 1);
+	if (m_Driver && m_Stage == 1 && (m_Driver->getPolygonMode() == UDriver::Filled))
+	{
+		static_cast<CDriverUser *>(m_Driver)->setRenderTarget(*m_BarrelTexU, 0, 0, 0, 0);
+		return true;
+	}
+	return false;
+}
+
+/// Returns true if a render target was fully drawn
+bool CStereoLibVR::endRenderTarget()
+{
+	// after rendering of course
+	// nlassert(m_SubStage > 1);
+	if (m_Driver && m_Stage == 6 && (m_Driver->getPolygonMode() == UDriver::Filled)) // set to 4 to turn off distortion of 2d gui
+	{
+		struct stereo_config st_conf;
+		hmd_get_stereo_config(m_DevicePtr->HMDDevice, &st_conf);
+		CTextureUser cu;
+		(static_cast<CDriverUser *>(m_Driver))->setRenderTarget(cu);
+		bool fogEnabled = m_Driver->fogEnabled();
+		m_Driver->enableFog(false);
+
+		m_Driver->setMatrixMode2D11();
+		CViewport vp = CViewport();
+		m_Driver->setViewport(vp);
+		uint32 width, height;
+		m_Driver->getWindowSize(width, height);
+		NL3D::IDriver *drvInternal = (static_cast<CDriverUser *>(m_Driver))->getDriver();
+		NL3D::CMaterial *barrelMat = m_BarrelMat.getObjectPtr();
+		barrelMat->setTexture(0, m_BarrelTex);
+		drvInternal->activePixelProgram(m_PixelProgram);
+
+		float w = float(m_BarrelQuadLeft.V1.x),// / float(width),
+			h = float(m_BarrelQuadLeft.V2.y),// / float(height),
+			x = float(m_BarrelQuadLeft.V0.x),/// / float(width),
+			y = float(m_BarrelQuadLeft.V0.y);// / float(height);
+
+		//TODO: stereo_config stuff
+		float lensViewportShift = st_conf.proj.projection_offset;
+
+		float lensCenterX = x + (w + lensViewportShift * 0.5f) * 0.5f;
+		float lensCenterY = y + h * 0.5f;
+		float screenCenterX = x + w * 0.5f;
+		float screenCenterY = y + h * 0.5f;
+		float scaleX = (w / 2 / st_conf.distort.scale);
+		float scaleY = (h / 2 / st_conf.distort.scale);
+		float scaleInX = (2 / w);
+		float scaleInY = (2 / h);
+		drvInternal->setPixelProgramConstant(0, lensCenterX, lensCenterY, 0.f, 0.f);
+		drvInternal->setPixelProgramConstant(1, screenCenterX, screenCenterY, 0.f, 0.f);
+		drvInternal->setPixelProgramConstant(2, scaleX, scaleY, 0.f, 0.f);
+		drvInternal->setPixelProgramConstant(3, scaleInX, scaleInY, 0.f, 0.f);
+		drvInternal->setPixelProgramConstant(4, 1, st_conf.distort.distortion_k);
+
+
+		m_Driver->drawQuad(m_BarrelQuadLeft, m_BarrelMat);
+
+		x = w;
+		lensCenterX = x + (w - lensViewportShift * 0.5f) * 0.5f;
+		screenCenterX = x + w * 0.5f;
+		drvInternal->setPixelProgramConstant(0, lensCenterX, lensCenterY, 0.f, 0.f);
+		drvInternal->setPixelProgramConstant(1, screenCenterX, screenCenterY, 0.f, 0.f);
+
+		m_Driver->drawQuad(m_BarrelQuadRight, m_BarrelMat);
+
+		drvInternal->activePixelProgram(NULL);
+		m_Driver->enableFog(fogEnabled);
+
+		return true;
+	}
+	return false;
+}
+
+NLMISC::CQuat CStereoLibVR::getOrientation() const
+{
+	if (m_OrientationCached)
+		return m_OrientationCache;
+
+	unsigned int t = NLMISC::CTime::getLocalTime();
+	hmd_update(m_DevicePtr->HMDDevice, &t);
+
+	float quat[4];
+	hmd_get_rotation(m_DevicePtr->HMDDevice, quat);
+	NLMISC::CMatrix coordsys;
+	float csys[] = {
+		1.0f, 0.0f, 0.0f, 0.0f, 
+		0.0f, 0.0f, -1.0f, 0.0f, 
+		0.0f, 1.0f, 0.0f, 0.0f, 
+		0.0f, 0.0f, 0.0f, 1.0f, 
+	};
+	coordsys.set(csys);
+	NLMISC::CMatrix matovr;
+	matovr.setRot(NLMISC::CQuat(quat[1], quat[2], quat[3], quat[0]));
+	NLMISC::CMatrix matr;
+	matr.rotateX(NLMISC::Pi * 0.5f); // fix this properly... :) (note: removing this allows you to use rift while lying down)
+	NLMISC::CMatrix matnel = matr * matovr * coordsys;
+	NLMISC::CQuat finalquat = matnel.getRot();
+	m_OrientationCache = finalquat;
+	m_OrientationCached = true;
+	return finalquat;
+}
+
+/// Get GUI shift
+void CStereoLibVR::getInterface2DShift(uint cid, float &x, float &y, float distance) const
+{
+#if 0
+
+	// todo: take into account m_EyePosition
+
+	NLMISC::CVector vector = CVector(0.f, -distance, 0.f);
+	NLMISC::CQuat rot = getOrientation();
+	rot.invert();
+	NLMISC::CMatrix mat;
+	mat.rotate(rot);
+	//if (m_Stage % 2) mat.translate(CVector(m_DevicePtr->HMDInfo.InterpupillaryDistance * -0.5f, 0.f, 0.f));
+	//else mat.translate(CVector(m_DevicePtr->HMDInfo.InterpupillaryDistance * 0.5f, 0.f, 0.f));
+	mat.translate(vector);
+	CVector proj = CStereoOVR::getCurrentFrustum(cid).project(mat.getPos());
+
+	NLMISC::CVector ipd;
+	if (m_Stage % 2) ipd = CVector(m_DevicePtr->HMDInfo.InterpupillaryDistance * -0.5f, 0.f, 0.f);
+	else ipd = CVector(m_DevicePtr->HMDInfo.InterpupillaryDistance * 0.5f, 0.f, 0.f);
+	CVector projipd = CStereoOVR::getCurrentFrustum(cid).project(vector + ipd);
+	CVector projvec = CStereoOVR::getCurrentFrustum(cid).project(vector);
+
+	x = (proj.x + projipd.x - projvec.x - 0.5f);
+	y = (proj.y + projipd.y - projvec.y - 0.5f);
+
+#elif 1
+
+	// Alternative method
+	// todo: take into account m_EyePosition
+
+	NLMISC::CVector vec = CVector(0.f, -distance, 0.f);
+	NLMISC::CVector ipd;
+	if (m_Stage % 2) ipd = CVector((m_DevicePtr->InterpupillaryDistance * m_Scale) * -0.5f, 0.f, 0.f);
+	else ipd = CVector((m_DevicePtr->InterpupillaryDistance * m_Scale) * 0.5f, 0.f, 0.f);
+	
+
+	NLMISC::CQuat rot = getOrientation();
+	NLMISC::CQuat modrot = NLMISC::CQuat(CVector(0.f, 1.f, 0.f), NLMISC::Pi);
+	rot = rot * modrot;
+	float p = NLMISC::Pi + atan2f(2.0f * ((rot.x * rot.y) + (rot.z * rot.w)), 1.0f - 2.0f * ((rot.y * rot.y) + (rot.w * rot.w)));
+	if (p > NLMISC::Pi) p -= NLMISC::Pi * 2.0f;	
+	float t = -atan2f(2.0f * ((rot.x * rot.w) + (rot.y * rot.z)), 1.0f - 2.0f * ((rot.z * rot.z) + (rot.w * rot.w)));// // asinf(2.0f * ((rot.x * rot.z) - (rot.w * rot.y)));
+	
+	CVector rotshift = CVector(p, 0.f, t) * -distance;
+	
+	CVector proj = CStereoLibVR::getCurrentFrustum(cid).project(vec + ipd + rotshift);
+
+	x = (proj.x - 0.5f);
+	y = (proj.y - 0.5f);
+
+#endif
+}
+
+void CStereoLibVR::setEyePosition(const NLMISC::CVector &v)
+{
+	m_EyePosition = v;
+}
+
+const NLMISC::CVector &CStereoLibVR::getEyePosition() const
+{
+	return m_EyePosition;
+}
+
+void CStereoLibVR::setScale(float s)
+{
+	m_EyePosition = m_EyePosition * (s / m_Scale);
+	m_Scale = s;
+}
+
+void CStereoLibVR::listDevices(std::vector<CStereoDeviceInfo> &devicesOut)
+{
+	// For now, LibVR doesn't support multiple devices
+	struct hmd *hmd = hmd_open_first(0);
+	if (hmd)
+	{
+                CStereoDeviceInfo deviceInfoOut;
+		CStereoLibVRDeviceHandle *handle = new CStereoLibVRDeviceHandle();
+		deviceInfoOut.Factory = static_cast<IStereoDeviceFactory *>(handle);
+		deviceInfoOut.Class = CStereoDeviceInfo::StereoHMD;
+		deviceInfoOut.Library = CStereoDeviceInfo::LibVR;
+		//TODO: manufacturer, produc name
+		//TODO: serial
+		devicesOut.push_back(deviceInfoOut);
+		hmd_close(hmd);
+	}
+}
+
+bool CStereoLibVR::isLibraryInUse()
+{
+	nlassert(s_DeviceCounter >= 0);
+	return s_DeviceCounter > 0;
+}
+
+void CStereoLibVR::releaseLibrary()
+{
+	nlassert(s_DeviceCounter == 0);
+}
+
+bool CStereoLibVR::isDeviceCreated()
+{
+	return m_DevicePtr->HMDDevice != NULL;
+}
+
+} /* namespace NL3D */
+
+#endif /* HAVE_LIBVR */
+
+/* end of file */