Merged default into ig_elevaton_port_to_linux

.hgeol

@@ -2,6 +2,9 @@
 **.h = native
 **.cpp = native
  
+**/database.xml = BIN
+**/msg.xml = BIN
+
 **.txt = native
 **.xml = native
 

.hgignore

@@ -146,6 +146,10 @@ external_stlport
 .svn
 thumbs.db
 Thumbs.db
+*.tpl.php
+.SyncID
+.SyncIgnore
+.SyncArchive
 
 # build
 code/nel/build/*
@@ -198,6 +202,16 @@ code/nel/tools/pacs/build_rbank/build_rbank
 code/ryzom/common/data_leveldesign/leveldesign/game_element/xp_table/skills.skill_tree
 code/ryzom/common/data_leveldesign/leveldesign/game_element/xp_table/xptable.xp_table
 code/ryzom/tools/server/sql/ryzom_admin_default_data.sql
+code/ryzom/tools/server/ryzom_ams/drupal
+code/ryzom/tools/server/ryzom_ams/drupal_module/ryzommanage/ams_lib/autoload
+code/ryzom/tools/server/ryzom_ams/drupal_module/ryzommanage/ams_lib/configs
+code/ryzom/tools/server/ryzom_ams/drupal_module/ryzommanage/ams_lib/cron
+code/ryzom/tools/server/ryzom_ams/drupal_module/ryzommanage/ams_lib/img
+code/ryzom/tools/server/ryzom_ams/drupal_module/ryzommanage/ams_lib/plugins
+code/ryzom/tools/server/ryzom_ams/drupal_module/ryzommanage/ams_lib/smarty
+code/ryzom/tools/server/ryzom_ams/drupal_module/ryzommanage/ams_lib/translations
+code/ryzom/tools/server/ryzom_ams/drupal_module/ryzommanage/ams_lib/libinclude.php
+code/ryzom/tools/server/ryzom_ams/www/html/templates_c
 
 # Linux server compile
 code/ryzom/server/src/entities_game_service/entities_game_service
@@ -211,3 +225,19 @@ code/ryzom/server/src/ryzom_welcome_service/ryzom_welcome_service
 code/ryzom/server/src/tick_service/tick_service
 # WebTT temp dir
 code/ryzom/tools/server/www/webtt/app/tmp
+code\ryzom\tools\server\ryzom_ams\old
+
+# AMS ignore
+code/ryzom/tools/server/ryzom_ams/www/config.php
+code/ryzom/tools/server/ryzom_ams/www/is_installed
+
+#tools and external dir's 
+external
+external_stlport
+nel_tools*
+ryzom_tools*
+
+#Dumps
+*.dmp
+
+

code/CMakeLists.txt

@@ -106,14 +106,16 @@ IF(WIN32)
   ENDIF(WITH_MFC)
 ENDIF(WIN32)
 
-FIND_PACKAGE(Threads REQUIRED)
 FIND_PACKAGE(LibXml2 REQUIRED)
 FIND_PACKAGE(PNG REQUIRED)
 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_DEFINITIONS ${LIBXML2_DEFINITIONS} -DLIBXML_STATIC)
   SET(LIBXML2_LIBRARIES ${LIBXML2_LIBRARIES} ${WINSOCK2_LIB})
 
   # on Mac OS X libxml2 requires iconv and liblzma
@@ -132,7 +134,7 @@ IF(FINAL_VERSION)
 ENDIF(FINAL_VERSION)
 
 IF(WITH_QT)
-  FIND_PACKAGE(Qt4 COMPONENTS QtCore QtGui QtXml REQUIRED)
+  FIND_PACKAGE(Qt4 COMPONENTS QtCore QtGui QtXml QtOpenGL REQUIRED)
 ENDIF(WITH_QT)
 
 IF(WITH_NEL)
@@ -142,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,32 @@
 #  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
+IF(CustomMFC_FIND_REQUIRED)
-FIND_PACKAGE(MFC)
+  SET(MFC_FIND_REQUIRED TRUE)
+ENDIF(CustomMFC_FIND_REQUIRED)
 
-SET(CUSTOM_MFC_DIR FALSE)
+IF(NOT MFC_DIR)
+  # If MFC have been found, remember their directory
+  IF(VC_DIR)
+    SET(MFC_STANDARD_DIR "${VC_DIR}/atlmfc")
+  ENDIF(VC_DIR)
 
-# 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
+    HINTS
     ${MFC_STANDARD_DIR}
   )
+ENDIF(NOT MFC_DIR)
 
-  IF(CustomMFC_FIND_REQUIRED)
+# Display an error message if MFC are not found, MFC_FOUND is updated
-    SET(MFC_FIND_REQUIRED TRUE)
+# User will be able to update MFC_DIR to the correct directory
-  ENDIF(CustomMFC_FIND_REQUIRED)
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(MFC DEFAULT_MSG MFC_DIR)
 
-  # Display an error message if MFC are not found, MFC_FOUND is updated
+IF(MFC_FOUND)
-  # User will be able to update MFC_DIR to the correct directory
+  SET(MFC_INCLUDE_DIR "${MFC_DIR}/include")
-  INCLUDE(FindPackageHandleStandardArgs)
+  INCLUDE_DIRECTORIES(${MFC_INCLUDE_DIR})
-  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,11 +39,12 @@ 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)
+
+  # Set CMake flag to use MFC DLL
+  SET(CMAKE_MFC_FLAG 2)
 ENDIF(MFC_FOUND)
 
 # TODO: create a macro which set MFC_DEFINITIONS, MFC_LIBRARY_DIR and MFC_INCLUDE_DIR for a project

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/FindDirectXSDK.cmake

@@ -6,8 +6,8 @@
 #  DXSDK_FOUND       - True if MAX SDK found.
 
 IF(DXSDK_DIR)
-    # Already in cache, be silent
+  # Already in cache, be silent
-    SET(DXSDK_FIND_QUIETLY TRUE)
+  SET(DXSDK_FIND_QUIETLY TRUE)
 ENDIF(DXSDK_DIR)
 
 FIND_PATH(DXSDK_DIR
@@ -26,10 +26,10 @@ FIND_PATH(DXSDK_DIR
 
 MACRO(FIND_DXSDK_LIBRARY MYLIBRARY MYLIBRARYNAME)        
   FIND_LIBRARY(${MYLIBRARY}
-               NAMES ${MYLIBRARYNAME}
+    NAMES ${MYLIBRARYNAME}
-               PATHS
+    PATHS
-               "${DXSDK_LIBRARY_DIR}"
+    "${DXSDK_LIBRARY_DIR}"
-               )
+    )
 ENDMACRO(FIND_DXSDK_LIBRARY MYLIBRARY MYLIBRARYNAME)
 
 IF(DXSDK_DIR)

code/CMakeModules/FindFreeType.cmake

@@ -1,17 +1,16 @@
 # - 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
+  freetype.h
   PATHS
   $ENV{FREETYPE_DIR}/include
   /usr/local/include
@@ -20,7 +19,7 @@ FIND_PATH(FREETYPE_INCLUDE_DIRS
   /opt/local/include
   /opt/csw/include
   /opt/include
-  PATH_SUFFIXES freetype freetype2
+  PATH_SUFFIXES freetype2/freetype freetype freetype2
 )
 
 # ft2build.h does not reside in the freetype include dir
@@ -33,6 +32,7 @@ FIND_PATH(FREETYPE_ADDITIONAL_INCLUDE_DIR
   /opt/local/include
   /opt/csw/include
   /opt/include
+  PATH_SUFFIXES freetype2
 )
 
 # combine both include directories into one variable
@@ -40,7 +40,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 +53,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,96 @@
+# - 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)
+    DETECT_EXPRESS_VERSION(${_VERSION})
+    IF(NOT MSVC_FIND_QUIETLY)
+      SET(_VERSION_STR ${_VERSION})
+      IF(MSVC_EXPRESS)
+        SET(_VERSION_STR "${_VERSION_STR} Express")
+      ENDIF(MSVC_EXPRESS)
+      MESSAGE(STATUS "Found Visual C++ ${_VERSION_STR} 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)
+
+MACRO(DETECT_EXPRESS_VERSION _VERSION)
+  GET_FILENAME_COMPONENT(MSVC_EXPRESS "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\${_VERSION}\\Setup\\VC;ProductDir]" ABSOLUTE)
+
+  IF(MSVC_EXPRESS AND NOT MSVC_EXPRESS STREQUAL "/registry")
+    SET(MSVC_EXPRESS ON)
+  ENDIF(MSVC_EXPRESS AND NOT MSVC_EXPRESS STREQUAL "/registry")
+ENDMACRO(DETECT_EXPRESS_VERSION)
+
+IF(MSVC12)
+  DETECT_VC_VERSION("12.0")
+
+  IF(NOT MSVC12_REDIST_DIR)
+    # If you have VC++ 2013 Express, put x64/Microsoft.VC120.CRT/*.dll in ${EXTERNAL_PATH}/redist
+    SET(MSVC12_REDIST_DIR "${EXTERNAL_PATH}/redist")
+  ENDIF(NOT MSVC11_REDIST_DIR)
+ELSEIF(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(MSVC12)
+
+# 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,12 @@
 #  License text for the above reference.)
 
 FIND_PROGRAM(Mercurial_HG_EXECUTABLE hg
-  DOC "mercurial command line client")
+  DOC "mercurial command line client"
+  PATHS
+    /opt/local/bin
+    "C:/Program Files/TortoiseHg"
+    "C:/Program Files (x86)/TortoiseHg"
+  )
 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,304 @@
 #  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
+# Values can be CURRENT or any existing versions 7.1, 8.0A, etc...
+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)
-    IF(TARGET_ARM)
+  ELSE(WINSDK${_VERSION}_DIR AND NOT WINSDK${_VERSION}_DIR STREQUAL "/registry")
-      SET(WINSDK8_SUFFIX "arm")
+    SET(WINSDK${_VERSION}_DIR "")
-    ELSEIF(TARGET_X64)
+  ENDIF(WINSDK${_VERSION}_DIR AND NOT WINSDK${_VERSION}_DIR STREQUAL "/registry")
-      SET(WINSDK8_SUFFIX "x64")
+ENDMACRO(DETECT_WINSDK_VERSION_HELPER)
-    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)
+MACRO(DETECT_WINSDK_VERSION _VERSION)
-GET_FILENAME_COMPONENT(WINSDK71_VERSION "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v7.1;ProductVersion]" NAME)
+  SET(WINSDK${_VERSION}_FOUND OFF)
+  DETECT_WINSDK_VERSION_HELPER("HKEY_CURRENT_USER" ${_VERSION})
 
-IF(WINSDK71_DIR)
+  IF(NOT WINSDK${_VERSION}_FOUND)
-  IF(NOT WindowsSDK_FIND_QUIETLY)
+    DETECT_WINSDK_VERSION_HELPER("HKEY_LOCAL_MACHINE" ${_VERSION})
-    MESSAGE(STATUS "Found Windows SDK ${WINSDK71_VERSION} in ${WINSDK71_DIR}")
+  ENDIF(NOT WINSDK${_VERSION}_FOUND)
-  ENDIF(NOT WindowsSDK_FIND_QUIETLY)
+ENDMACRO(DETECT_WINSDK_VERSION)
-ENDIF(WINSDK71_DIR)
 
-GET_FILENAME_COMPONENT(WINSDKCURRENT_DIR  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows;CurrentInstallFolder]" ABSOLUTE CACHE)
+SET(WINSDK_VERSIONS "8.0" "8.0A" "7.1" "7.1A" "7.0" "7.0A" "6.1" "6.0" "6.0A")
-GET_FILENAME_COMPONENT(WINSDKCURRENT_VERSION "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows;CurrentVersion]" NAME)
+SET(WINSDK_DETECTED_VERSIONS)
 
-IF(WINSDKCURRENT_DIR)
+# Search all supported Windows SDKs
-  IF(NOT WindowsSDK_FIND_QUIETLY)
+FOREACH(_VERSION ${WINSDK_VERSIONS})
-    MESSAGE(STATUS "Found Windows SDK ${WINSDKCURRENT_VERSION} in ${WINSDKCURRENT_DIR}")
+  DETECT_WINSDK_VERSION(${_VERSION})
-  ENDIF(NOT WindowsSDK_FIND_QUIETLY)
-ENDIF(WINSDKCURRENT_DIR)
 
+  IF(WINSDK${_VERSION}_FOUND)
+    LIST(APPEND WINSDK_DETECTED_VERSIONS ${_VERSION})
+  ENDIF(WINSDK${_VERSION}_FOUND)
+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)
+
+SET(WINSDKCURRENT_VERSION_INCLUDE $ENV{INCLUDE})
+
+IF(WINSDKCURRENT_VERSION_INCLUDE)
+  FILE(TO_CMAKE_PATH "${WINSDKCURRENT_VERSION_INCLUDE}" WINSDKCURRENT_VERSION_INCLUDE)
+ENDIF(WINSDKCURRENT_VERSION_INCLUDE)
+
+SET(WINSDKENV_DIR $ENV{WINSDK_DIR})
+
+MACRO(FIND_WINSDK_VERSION_HEADERS)
+  IF(WINSDK_DIR AND NOT WINSDK_VERSION)
+    # Search version in headers
+    IF(EXISTS ${WINSDK_DIR}/include/Msi.h)
+      SET(_MSI_FILE ${WINSDK_DIR}/include/Msi.h)
+    ENDIF(EXISTS ${WINSDK_DIR}/include/Msi.h)
+
+    IF(_MSI_FILE)
+      # Look for Windows SDK 8.0
+      FILE(STRINGS ${_MSI_FILE} _CONTENT REGEX "^#ifndef NTDDI_WIN8")
+
+      IF(_CONTENT)
+        SET(WINSDK_VERSION "8.0")
+      ENDIF(_CONTENT)
+      
+      IF(NOT WINSDK_VERSION)
+        # Look for Windows SDK 7.0
+        FILE(STRINGS ${_MSI_FILE} _CONTENT REGEX "^#ifndef NTDDI_WIN7")
+        
+        IF(_CONTENT)
+          IF(EXISTS ${WINSDK_DIR}/include/winsdkver.h)
+            SET(_WINSDKVER_FILE ${WINSDK_DIR}/include/winsdkver.h)
+          ELSEIF(EXISTS ${WINSDK_DIR}/include/WinSDKVer.h)
+            SET(_WINSDKVER_FILE ${WINSDK_DIR}/include/WinSDKVer.h)
+          ENDIF(EXISTS ${WINSDK_DIR}/include/winsdkver.h)
+
+          IF(_WINSDKVER_FILE)
+            # Load WinSDKVer.h content
+            FILE(STRINGS ${_WINSDKVER_FILE} _CONTENT REGEX "^#define NTDDI_MAXVER")
+
+            # Get NTDDI_MAXVER value
+            STRING(REGEX REPLACE "^.*0x([0-9A-Fa-f]+).*$" "\\1" _WINSDKVER "${_CONTENT}")
+
+            # In Windows SDK 7.1, NTDDI_MAXVER is wrong
+            IF(_WINSDKVER STREQUAL "06010000")
+              SET(WINSDK_VERSION "7.1")
+            ELSEIF(_WINSDKVER STREQUAL "0601")
+              SET(WINSDK_VERSION "7.0A")
+            ELSE(_WINSDKVER STREQUAL "06010000")
+              MESSAGE(FATAL_ERROR "Can't determine Windows SDK version with NTDDI_MAXVER 0x${_WINSDKVER}")
+            ENDIF(_WINSDKVER STREQUAL "06010000")
+          ELSE(_WINSDKVER_FILE)
+            SET(WINSDK_VERSION "7.0")
+          ENDIF(_WINSDKVER_FILE)
+        ENDIF(_CONTENT)
+      ENDIF(NOT WINSDK_VERSION)
+
+      IF(NOT WINSDK_VERSION)
+        # Look for Windows SDK 6.0
+        FILE(STRINGS ${_MSI_FILE} _CONTENT REGEX "^#ifndef NTDDI_VISTA")
+        
+        IF(_CONTENT)
+          SET(WINSDK_VERSION "6.0")
+        ENDIF(_CONTENT)
+      ENDIF(NOT WINSDK_VERSION)
+
+      IF(NOT WINSDK_VERSION)
+        # Look for Windows SDK 5.2
+        FILE(STRINGS ${_MSI_FILE} _CONTENT REGEX "^#ifndef NTDDI_WS03SP1")
+
+        IF(_CONTENT)
+          SET(WINSDK_VERSION "5.2")
+        ENDIF(_CONTENT)
+      ENDIF(NOT WINSDK_VERSION)
+
+      IF(NOT WINSDK_VERSION)
+        # Look for Windows SDK 5.1
+        FILE(STRINGS ${_MSI_FILE} _CONTENT REGEX "^#ifndef NTDDI_WINXP")
+
+        IF(_CONTENT)
+          SET(WINSDK_VERSION "5.1")
+        ENDIF(_CONTENT)
+      ENDIF(NOT WINSDK_VERSION)
+
+      IF(NOT WINSDK_VERSION)
+        # Look for Windows SDK 5.0
+        FILE(STRINGS ${_MSI_FILE} _CONTENT REGEX "^#ifndef NTDDI_WIN2K")
+
+        IF(_CONTENT)
+          SET(WINSDK_VERSION "5.0")
+        ENDIF(_CONTENT)
+      ENDIF(NOT WINSDK_VERSION)
+    ELSE(_MSI_FILE)
+      MESSAGE(FATAL_ERROR "Unable to find Msi.h in ${WINSDK_DIR}")
+    ENDIF(_MSI_FILE)
+  ENDIF(WINSDK_DIR AND NOT WINSDK_VERSION)
+ENDMACRO(FIND_WINSDK_VERSION_HEADERS)
+
+MACRO(USE_CURRENT_WINSDK)
+  SET(WINSDK_DIR "")
+  SET(WINSDK_VERSION "")
+  SET(WINSDK_VERSION_FULL "")
+
+  # Use WINSDK environment variable
+  IF(WINSDKENV_DIR AND EXISTS ${WINSDKENV_DIR}/include/Windows.h)
+    SET(WINSDK_DIR ${WINSDKENV_DIR})
+  ENDIF(WINSDKENV_DIR AND EXISTS ${WINSDKENV_DIR}/include/Windows.h)
+
+  # Use INCLUDE environment variable
+  IF(NOT WINSDK_DIR AND WINSDKCURRENT_VERSION_INCLUDE)
+    FOREACH(_INCLUDE ${WINSDKCURRENT_VERSION_INCLUDE})
+      FILE(TO_CMAKE_PATH ${_INCLUDE} _INCLUDE)
+
+      # Look for Windows.h because there are several paths
+      IF(EXISTS ${_INCLUDE}/Windows.h)
+        STRING(REGEX REPLACE "/(include|INCLUDE|Include)" "" WINSDK_DIR ${_INCLUDE})
+        MESSAGE(STATUS "Found Windows SDK environment variable in ${WINSDK_DIR}")
+        BREAK()
+      ENDIF(EXISTS ${_INCLUDE}/Windows.h)
+    ENDFOREACH(_INCLUDE)
+  ENDIF(NOT WINSDK_DIR AND WINSDKCURRENT_VERSION_INCLUDE)
+
+  IF(WINSDK_DIR)
+    # Compare WINSDK_DIR with registered Windows SDKs
+    FOREACH(_VERSION ${WINSDK_DETECTED_VERSIONS})
+      IF(WINSDK_DIR STREQUAL "${WINSDK${_VERSION}_DIR}")
+        SET(WINSDK_VERSION ${_VERSION})
+        SET(WINSDK_VERSION_FULL "${WINSDK${WINSDK_VERSION}_VERSION_FULL}")
+        BREAK()
+      ENDIF(WINSDK_DIR STREQUAL "${WINSDK${_VERSION}_DIR}")
+    ENDFOREACH(_VERSION)
+
+    FIND_WINSDK_VERSION_HEADERS()
+  ENDIF(WINSDK_DIR)
+
+  IF(NOT WINSDK_DIR)
+    # Use Windows SDK versions installed with VC++ when possible
+    IF(MSVC12)
+      SET(WINSDK_VERSION "8.1A")
+    ELSEIF(MSVC11)
+      SET(WINSDK_VERSION "8.0A")
+    ELSEIF(MSVC10)
+      IF(NOT TARGET_X64 OR NOT MSVC_EXPRESS)
+        SET(WINSDK_VERSION "7.0A")
+      ENDIF(NOT TARGET_X64 OR NOT MSVC_EXPRESS)
+    ELSEIF(MSVC90)
+      IF(NOT MSVC_EXPRESS)
+        SET(WINSDK_VERSION "6.0A")
+      ENDIF(NOT MSVC_EXPRESS)
+    ELSEIF(MSVC80)
+      IF(NOT MSVC_EXPRESS)
+        # TODO: fix this version
+        SET(WINSDK_VERSION "5.2A")
+      ENDIF(NOT MSVC_EXPRESS)
+    ELSE(MSVC12)
+      MESSAGE(FATAL_ERROR "Your compiler is either too old or too recent, please update this CMake module.")
+    ENDIF(MSVC12)
+
+    # Use installed Windows SDK
+    IF(NOT WINSDK_VERSION)
+      IF(WINSDK7.1_FOUND)
+        SET(WINSDK_VERSION "7.1")
+      ELSEIF(WINSDK7.0_FOUND)
+        SET(WINSDK_VERSION "7.0")
+      ELSEIF(WINSDK6.1_FOUND)
+        SET(WINSDK_VERSION "6.1")
+      ELSEIF(WINSDK6.0_FOUND)
+        SET(WINSDK_VERSION "6.0")
+      ELSE(WINSDK7.1_FOUND)
+        MESSAGE(FATAL_ERROR "You have no compatible Windows SDK installed.")
+      ENDIF(WINSDK7.1_FOUND)
+    ENDIF(NOT WINSDK_VERSION)
+
+    # Look for correct registered Windows SDK version
+    FOREACH(_VERSION ${WINSDK_DETECTED_VERSIONS})
+      IF(WINSDK_VERSION STREQUAL _VERSION)
+        SET(WINSDK_VERSION_FULL "${WINSDK${WINSDK_VERSION}_VERSION_FULL}")
+        SET(WINSDK_DIR "${WINSDK${WINSDK_VERSION}_DIR}")
+        BREAK()
+      ENDIF(WINSDK_VERSION STREQUAL _VERSION)
+    ENDFOREACH(_VERSION)
+  ENDIF(NOT WINSDK_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,8 +25,6 @@ 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
@@ -35,35 +32,43 @@ 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)
-    GET_TARGET_PROPERTY(_targetType ${_target} TYPE)
+
-    IF(${_targetType} STREQUAL SHARED_LIBRARY OR ${_targetType} STREQUAL MODULE_LIBRARY)
+  IF(${_targetType} STREQUAL SHARED_LIBRARY OR ${_targetType} STREQUAL MODULE_LIBRARY)
-      LIST(APPEND _FLAGS " -fPIC")
+    LIST(APPEND _FLAGS " ${CMAKE_SHARED_LIBRARY_CXX_FLAGS}")
-    ENDIF(${_targetType} STREQUAL SHARED_LIBRARY OR ${_targetType} STREQUAL MODULE_LIBRARY)
+  ELSE(${_targetType} STREQUAL SHARED_LIBRARY OR ${_targetType} STREQUAL MODULE_LIBRARY)
-  ENDIF(NOT MSVC)
+    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)
 
   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)
-  FOREACH(item ${DEFINITIONS})
+  IF(DEFINITIONS)
-    LIST(APPEND GLOBAL_DEFINITIONS " -D${item}")
+    FOREACH(item ${DEFINITIONS})
-  ENDFOREACH(item)
+      LIST(APPEND GLOBAL_DEFINITIONS " -D${item}")
+    ENDFOREACH(item)
+  ENDIF(DEFINITIONS)
 
   GET_DIRECTORY_PROPERTY(DEFINITIONS COMPILE_DEFINITIONS_${_UPPER_BUILD})
-  FOREACH(item ${DEFINITIONS})
+  IF(DEFINITIONS)
-    LIST(APPEND GLOBAL_DEFINITIONS " -D${item}")
+    FOREACH(item ${DEFINITIONS})
-  ENDFOREACH(item)
+      LIST(APPEND GLOBAL_DEFINITIONS " -D${item}")
+    ENDFOREACH(item)
+  ENDIF(DEFINITIONS)
 
   GET_TARGET_PROPERTY(oldProps ${_target} COMPILE_FLAGS)
   IF(oldProps)
@@ -75,16 +80,41 @@ 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}")
   LIST(APPEND _FLAGS " ${_directory_flags}")
   LIST(APPEND _FLAGS " ${_directory_definitions}")
 
-  STRING(REGEX REPLACE " +" " " _FLAGS ${_FLAGS})
-
   # Format definitions
-  SEPARATE_ARGUMENTS(_FLAGS)
+  IF(MSVC)
+    # Fix path with space
+    SEPARATE_ARGUMENTS(_FLAGS UNIX_COMMAND "${_FLAGS}")
+  ELSE(MSVC)
+    STRING(REGEX REPLACE " +" " " _FLAGS ${_FLAGS})
+    SEPARATE_ARGUMENTS(_FLAGS)
+  ENDIF(MSVC)
 
   IF(CLANG)
     # Determining all architectures and get common flags
@@ -178,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 "")
@@ -237,6 +270,25 @@ 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(_STATIC_LIBRARY_FLAGS ${_targetName} STATIC_LIBRARY_FLAGS)
+    IF(NOT _STATIC_LIBRARY_FLAGS)
+      SET(_STATIC_LIBRARY_FLAGS)
+    ENDIF(NOT _STATIC_LIBRARY_FLAGS)
+    SET(_STATIC_LIBRARY_FLAGS "${PCH_OUTPUT}.obj ${_STATIC_LIBRARY_FLAGS}")
+
+    GET_TARGET_PROPERTY(_LINK_FLAGS ${_targetName} LINK_FLAGS)
+    IF(NOT _LINK_FLAGS)
+      SET(_LINK_FLAGS)
+    ENDIF(NOT _LINK_FLAGS)
+    SET(_LINK_FLAGS "${PCH_OUTPUT}.obj ${_LINK_FLAGS}")
+
+    SET_TARGET_PROPERTIES(${_targetName} PROPERTIES STATIC_LIBRARY_FLAGS ${_STATIC_LIBRARY_FLAGS} LINK_FLAGS ${_LINK_FLAGS})
   ELSE(MSVC)
     # for use with distcc and gcc >4.0.1 if preprocessed files are accessible
     # on all remote machines set
@@ -324,17 +376,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")
@@ -346,10 +387,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

@@ -123,12 +123,8 @@ MACRO(NL_DEFAULT_PROPS name label)
       VERSION ${NL_VERSION}
       SOVERSION ${NL_VERSION_MAJOR}
       COMPILE_FLAGS "/GA"
-      LINK_FLAGS "/VERSION:${NL_VERSION}")
+      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)
 
 ###
@@ -247,6 +243,11 @@ MACRO(NL_SETUP_DEFAULT_OPTIONS)
   ELSE(WIN32)
     OPTION(WITH_STATIC            "With static libraries."                        OFF)
   ENDIF(WIN32)
+  IF (WITH_STATIC)
+    OPTION(WITH_STATIC_LIBXML2    "With static libxml2"                           ON )
+  ELSE(WITH_STATIC)
+    OPTION(WITH_STATIC_LIBXML2    "With static libxml2"                           OFF)
+  ENDIF(WITH_STATIC)
   OPTION(WITH_STATIC_DRIVERS      "With static drivers."                          OFF)
   IF(WIN32)
     OPTION(WITH_EXTERNAL          "With provided external."                       ON )
@@ -319,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)
@@ -341,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)
@@ -382,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
 
@@ -395,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)
@@ -411,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
@@ -530,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
@@ -582,7 +595,7 @@ MACRO(NL_SETUP_BUILD)
 
     SET(NL_DEBUG_CFLAGS "/Zi /MDd /RTC1 /D_DEBUG ${DEBUG_CFLAGS} ${NL_DEBUG_CFLAGS}")
     SET(NL_RELEASE_CFLAGS "/MD /DNDEBUG ${RELEASE_CFLAGS} ${NL_RELEASE_CFLAGS}")
-    SET(NL_DEBUG_LINKFLAGS "/DEBUG /OPT:NOREF /OPT:NOICF /NODEFAULTLIB:msvcrt /INCREMENTAL:YES ${NL_DEBUG_LINKFLAGS}")
+    SET(NL_DEBUG_LINKFLAGS "/DEBUG /OPT:NOREF /OPT:NOICF /NODEFAULTLIB:msvcrt ${MSVC_INCREMENTAL_YES_FLAG} ${NL_DEBUG_LINKFLAGS}")
     SET(NL_RELEASE_LINKFLAGS "/OPT:REF /OPT:ICF /INCREMENTAL:NO ${NL_RELEASE_LINKFLAGS}")
 
     IF(WITH_WARNINGS)
@@ -776,12 +789,7 @@ MACRO(NL_SETUP_BUILD)
             SET(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} ${XARCH}-Wl,-macosx_version_min,${CMAKE_OSX_DEPLOYMENT_TARGET}")
           ENDIF(CMAKE_IOS_SIMULATOR_SYSROOT AND TARGET_X86)
         ELSE(IOS)
-          IF(CMAKE_OSX_SYSROOT)
-            ADD_PLATFORM_FLAGS("-isysroot ${CMAKE_OSX_SYSROOT}")
-          ENDIF(CMAKE_OSX_SYSROOT)
-
           # Always force -mmacosx-version-min to override environement variable
-          ADD_PLATFORM_FLAGS("-mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
           SET(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -Wl,-macosx_version_min,${CMAKE_OSX_DEPLOYMENT_TARGET}")
         ENDIF(IOS)
 
@@ -889,20 +897,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
@@ -1056,74 +1067,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)
@@ -1139,15 +1090,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/README

@@ -12,7 +12,7 @@ each other so you can use only the parts you really need in your project.
 If you want know more about the library content and functionalities, you
 should take a look on the documents present in the doc directory.
 
-Ryzom Core is currently developped and tested under GNU/Linux and Windows
+Ryzom Core is currently developed and tested under GNU/Linux and Windows
 environments. 
 
 
@@ -29,4 +29,7 @@ file for for more details on license terms and other legal issues.
 Installation
 ------------
 
-Please visit http://dev.ryzom.com for more information.
+Please visit https://ryzomcore.atlassian.net/wiki/display/RC/Ryzom+Core+Home for more information.
+In particular the Getting Started section on the right side of the webpage includes build
+instructions for Windows, Linux and Mac.
+

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})
@@ -68,7 +76,11 @@ IF(WITH_NEL_SAMPLES)
   ADD_SUBDIRECTORY(samples)
 ENDIF(WITH_NEL_SAMPLES)
 
-IF(WITH_NEL_TOOLS)
+# Allow to compile only max plugins without other tools.
-  FIND_PACKAGE(Squish)
+IF(WITH_NEL_TOOLS OR WITH_NEL_MAXPLUGIN)
+  IF(WITH_NEL_TOOLS)
+    FIND_PACKAGE(Squish)
+  ENDIF(WITH_NEL_TOOLS)
   ADD_SUBDIRECTORY(tools)
-ENDIF(WITH_NEL_TOOLS)
+ENDIF(WITH_NEL_TOOLS OR WITH_NEL_MAXPLUGIN)
+

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/ps_attrib_maker_bin_op_inline.h

@@ -128,7 +128,7 @@ inline uint32 CPSAttribMakerBinOp<uint32>::getMinValue(void) const
 		{
 			uint32 lhs = _Arg[0]->getMinValue();
 			uint32 rhs = _Arg[1]->getMaxValue();
-			return lhs > rhs ? 0 : lhs - rhs;
+			return rhs > lhs ? 0 : lhs - rhs;
 		}
 		break;
 		default:
@@ -153,7 +153,7 @@ inline uint32 CPSAttribMakerBinOp<uint32>::getMaxValue(void) const
 		{
 			uint32 lhs = _Arg[0]->getMaxValue();
 			uint32 rhs = _Arg[1]->getMinValue();
-			return lhs > rhs ? 0 : lhs - rhs;
+			return rhs > lhs ? 0 : lhs - rhs;
 		}
 		break;
 		default:

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/gui/group_container_base.h

@@ -74,7 +74,7 @@ namespace NLGUI
 			REFLECT_SINT32("rollover_container_alpha", getRolloverAlphaContainerAsSInt32, setRolloverAlphaContainer);
 			REFLECT_BOOL("use_global_alpha_settings", isUsingGlobalAlpha, setUseGlobalAlpha);
 			REFLECT_STRING("on_alpha_settings_changed", getAHOnAlphaSettingsChanged, setAHOnAlphaSettingsChanged);
-			REFLECT_STRING("on_alpha_settings_changed_aparams", getAHOnAlphaSettingsChangedParams, setAHOnAlphaSettingsChangedParams);
+			REFLECT_STRING("on_alpha_settings_changed_params", getAHOnAlphaSettingsChangedParams, setAHOnAlphaSettingsChangedParams);
 		REFLECT_EXPORT_END
 
 		virtual bool isMoving() const{ return false; }

code/nel/include/nel/gui/interface_link.h

@@ -66,6 +66,11 @@ namespace NLGUI
 			  */
 			bool affect(const CInterfaceExprValue &value);
 		};
+		struct CCDBTargetInfo
+		{
+			NLMISC::CRefPtr<NLMISC::CCDBNodeLeaf> Leaf;
+			std::string LeafName;
+		};
 
 
 		/// Updates triggered interface links when triggered by the observed branch
@@ -85,7 +90,7 @@ namespace NLGUI
 		  * If there are no target element, the link is permanent (removed at exit)
 		  * NB : The target is not updated during this call.
 		  */
-		bool				init(const std::vector<CTargetInfo> &targets, const std::string &expr, const std::string &actionHandler, const std::string &ahParams, const std::string &ahCond, CInterfaceGroup *parent);
+		bool				init(const std::vector<CTargetInfo> &targets, const std::vector<CCDBTargetInfo> &cdbTargets, const std::string &expr, const std::string &actionHandler, const std::string &ahParams, const std::string &ahCond, CInterfaceGroup *parent);
 		// force all the links that have been created to update their targets. This can be called when the interface has been loaded, and when the databse entries have been retrieved.
 		static void			updateAllLinks();
 		// force all trigered links to be updated
@@ -119,6 +124,7 @@ namespace NLGUI
 		  * \return true if all targets are valid
 		  */
 		static bool splitLinkTargets(const std::string &targets, CInterfaceGroup *parentGroup, std::vector<CInterfaceLink::CTargetInfo> &targetsVect);
+		static bool splitLinkTargetsExt(const std::string &targets, CInterfaceGroup *parentGroup, std::vector<CInterfaceLink::CTargetInfo> &targetsVect, std::vector<CInterfaceLink::CCDBTargetInfo> &cdbTargetsVect);
 	////////////////////////////////////////////////////////////////////////////////////////////////////////
 	private:
 		friend struct CRemoveTargetPred;
@@ -135,12 +141,14 @@ namespace NLGUI
 		typedef std::vector<NLMISC::ICDBNode *> TNodeVect;
 	private:
 		std::vector<CTarget>         _Targets;
+		std::vector<CCDBTargetInfo>	 _CDBTargets;
 		TNodeVect					 _ObservedNodes;
 		std::string					 _Expr;
 		CInterfaceExprNode			 *_ParseTree;
 		std::string					 _ActionHandler;
 		std::string					 _AHParams;
 		std::string					 _AHCond;
+		CInterfaceExprNode			*_AHCondParsed;
 		CInterfaceGroup				*_AHParent;
 		static TLinkList             _LinkList;
 		TLinkList::iterator			 _ListEntry;

code/nel/include/nel/gui/lua_helper.h

@@ -217,6 +217,7 @@ namespace NLGUI
 		void				clear() { setTop(0); }
 		int					getTop();
 		bool				empty() { return getTop() == 0; }
+		void				pushGlobalTable();		
 		void				pushValue(int index);  // copie nth element of stack to the top of the stack
 		void				remove(int index);     // remove nth element of stack
 		void				insert(int index);     // insert last element of the stack before the given position
@@ -301,7 +302,8 @@ namespace NLGUI
 		/** Helper : Execute a function by name. Lookup for the function is done in the table at the index 'funcTableIndex'
 		  * the behaviour is the same than with call of pcall.
 		  */
-		int                 pcallByName(const char *functionName, int nargs, int nresults, int funcTableIndex = LUA_GLOBALSINDEX, int errfunc = 0);
+		int                 pcallByNameGlobal(const char *functionName, int nargs, int nresults, int errfunc = 0);
+		int                 pcallByName(const char *functionName, int nargs, int nresults, int funcTableIndex, int errfunc = 0);
 
 		// push a C closure (pop n element from the stack and associate with the function)
 		void				pushCClosure(lua_CFunction function, int n);
@@ -367,6 +369,7 @@ namespace NLGUI
 		CLuaState &operator=(const CLuaState &/* other */) { nlassert(0); return *this; }
 
 		void				executeScriptInternal(const std::string &code, const std::string &dbgSrc, int numRet = 0);
+		int                 pcallByNameInternal(const char *functionName, int nargs, int nresults, int errfunc, int initialStackSize);
 
 	};
 

code/nel/include/nel/gui/lua_helper_inline.h

@@ -42,10 +42,16 @@ inline void CLuaState::checkIndex(int index)
 	//H_AUTO(Lua_CLuaState_checkIndex)
 	// NB : more restrictive test that in the documentation there, because
 	// we don't expose the check stack function
+#if LUA_VERSION_NUM >= 502
+	nlassert( (index!=0 && abs(index) <= getTop())
+		|| index == LUA_REGISTRYINDEX
+		);
+#else
 	nlassert( (index!=0 && abs(index) <= getTop())
 		|| index == LUA_REGISTRYINDEX
 		|| index == LUA_GLOBALSINDEX
 		);
+#endif
 }
 
 //================================================================================
@@ -75,6 +81,18 @@ inline void CLuaState::setTop(int index)
 	lua_settop(_State, index);
 }
 
+//================================================================================
+inline void CLuaState::pushGlobalTable()
+{
+	//H_AUTO(Lua_CLuaState_pushGlobalTable)
+#if LUA_VERSION_NUM >= 502
+	lua_pushglobaltable(_State);
+#else
+	checkIndex(LUA_GLOBALSINDEX);
+	lua_pushvalue(_State, LUA_GLOBALSINDEX);
+#endif
+}
+
 //================================================================================
 inline void CLuaState::pushValue(int index)
 {
@@ -243,7 +261,11 @@ inline size_t CLuaState::strlen(int index)
 {
 	//H_AUTO(Lua_CLuaState_strlen)
 	checkIndex(index);
+#if LUA_VERSION_NUM >= 502
+	return lua_rawlen(_State, index);
+#else
 	return lua_strlen(_State, index);
+#endif
 }
 
 //================================================================================
@@ -342,7 +364,11 @@ inline bool         CLuaState::equal(int index1, int index2)
 	//H_AUTO(Lua_CLuaState_equal)
 	checkIndex(index1);
 	checkIndex(index2);
+#if LUA_VERSION_NUM >= 502
+	return lua_compare(_State, index1, index2, LUA_OPEQ) != 0;
+#else
 	return lua_equal(_State, index1, index2) != 0;
+#endif
 }
 
 //================================================================================
@@ -376,7 +402,11 @@ inline bool         CLuaState::lessThan(int index1, int index2)
 	//H_AUTO(Lua_CLuaState_lessThan)
 	checkIndex(index1);
 	checkIndex(index2);
+#if LUA_VERSION_NUM >= 502
+	return lua_compare(_State, index1, index2, LUA_OPLT) != 0;
+#else
 	return lua_lessthan(_State, index1, index2) != 0;
+#endif
 }
 
 

code/nel/include/nel/gui/widget_manager.h

@@ -444,7 +444,7 @@ namespace NLGUI
 		}
 
 		float getAlphaRolloverSpeed();
-		void resetAlphaRolloverSpeed();
+		void resetAlphaRolloverSpeedProps();
 
 		void setContainerAlpha( uint8 alpha );
 		uint8 getContainerAlpha() const { return _ContainerAlpha; }
@@ -454,6 +454,7 @@ namespace NLGUI
 		uint8 getGlobalRolloverFactorContainer() const { return _GlobalRolloverFactorContainer; }
 
 		void updateGlobalAlphas();
+		void resetGlobalAlphasProps();
 
 		const SInterfaceTimes& getInterfaceTimes() const{ return interfaceTimes; }
 		void updateInterfaceTimes( const SInterfaceTimes &times ){ interfaceTimes = times; }
@@ -528,6 +529,11 @@ namespace NLGUI
 		NLMISC::CCDBNodeLeaf *_AProp;
 		NLMISC::CCDBNodeLeaf *_AlphaRolloverSpeedDB;
 
+		NLMISC::CCDBNodeLeaf *_GlobalContentAlphaDB;
+		NLMISC::CCDBNodeLeaf *_GlobalContainerAlphaDB;
+		NLMISC::CCDBNodeLeaf *_GlobalContentRolloverFactorDB;
+		NLMISC::CCDBNodeLeaf *_GlobalContainerRolloverFactorDB;
+		
 		uint8 _ContainerAlpha;
 		uint8 _GlobalContentAlpha;
 		uint8 _GlobalContainerAlpha;

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/debug.h

@@ -586,7 +586,7 @@ template<class T, class U>	inline T	type_cast(U o)
 #ifdef NL_ISO_CPP0X_AVAILABLE
 #	define nlctassert(cond) static_assert(cond, "Compile time assert in "#cond)
 #else
-#	define nlctassert(cond) sizeof(uint[(cond) ? 1 : 0])
+#	define nlctassert(cond) (void)sizeof(uint[(cond) ? 1 : 0])
 #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/include/nel/misc/types_nl.h

@@ -104,6 +104,8 @@
 			// Windows 64bits platform SDK compilers doesn't support inline assembler
 #			define NL_NO_ASM
 #		endif
+#		undef _WIN32_WINNT
+#		define _WIN32_WINNT 0x0600 // force VISTA minimal version in 64 bits
 #	endif
 	// define NOMINMAX to be sure that windows includes will not define min max macros, but instead, use the stl template
 #	define NOMINMAX

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))
 	{
-		nlwarning("setRenderTarget return false with initial texture for bloom effect\n");
+		NL3D::CTextureUser txt = (_InitBloomEffect) ? (CTextureUser(_InitText)) : (CTextureUser());
-		return;
+		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;
+
-	virtual bool			isVertexProgramEmulated () const;
+	
-	virtual bool			activeVertexProgram (CVertexProgram *program);
+
-	virtual void			setConstant (uint index, float, float, float, float);
+
-	virtual void			setConstant (uint index, double, double, double, double);
+	/// \name Vertex Program
-	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);
+	// Order of preference
-	virtual void			setConstant (uint index, uint num, const double *src);
+	// - activeVertexProgram
-	virtual void			setConstantMatrix (uint index, IDriver::TMatrix matrix, IDriver::TTransform transform);
+	// - CMaterial pass[n] VP (uses activeVertexProgram, but does not override if one already set by code)
-	virtual void			setConstantFog (uint index);
+	// - 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);
+	// @}
+
+
+
+	/// \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) 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,101 +262,130 @@ void dump(const CVPParser::TProgram &prg, std::string &dest)
 
 // ***************************************************************************
 
+bool CDriverD3D::compileVertexProgram(NL3D::CVertexProgram *program)
+{
+	// Program setuped ?
+	if (program->m_DrvInfo == NULL)
+	{
+		// 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("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->m_DrvInfo = *itTex;
+
+		/** 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(source->SourcePtr, parsedProgram, errorOutput);
+		if (!result)
+		{
+			nlwarning("Unable to parse a vertex program :");
+			nlwarning(errorOutput.c_str());
+			#ifdef NL_DEBUG_D3D
+				nlassert(0);
+			#endif // NL_DEBUG_D3D
+			return false;
+		}
+
+		// tmp fix for Radeon 8500/9000/9200
+		// Currently they hang when PaletteSkin / SkinWeight are present in the vertex declaration, but not used
+		// so disable them in the vertex declaration
+		// We don't use these component in vertex programs currently..
+		#ifdef NL_DEBUG
+			for(uint k = 0; k < parsedProgram.size(); ++k)
+			{
+				for(uint l = 0; l < parsedProgram[k].getNumUsedSrc(); ++l)
+				{
+					const CVPOperand &op = parsedProgram[k].getSrc(l);
+					if (op.Type == CVPOperand::InputRegister)
+					{
+						nlassert(op.Value.InputRegisterValue != CVPOperand::IWeight);
+						nlassert(op.Value.InputRegisterValue != CVPOperand::IPaletteSkin);
+					}
+				}
+			}
+		#endif
+
+		// Dump the vertex program
+		std::string dest;
+		dump(parsedProgram, dest);
+#ifdef NL_DEBUG_D3D
+		nlinfo("Assemble Vertex Shader : ");
+		string::size_type lineBegin = 0;
+		string::size_type lineEnd;
+		while ((lineEnd = dest.find('\n', lineBegin)) != string::npos)
+		{
+			nlinfo(dest.substr (lineBegin, lineEnd-lineBegin).c_str());
+			lineBegin = lineEnd+1;
+		}
+		nlinfo(dest.substr (lineBegin, lineEnd-lineBegin).c_str());
+#endif // NL_DEBUG_D3D
+
+		LPD3DXBUFFER pShader;
+		LPD3DXBUFFER pErrorMsgs;
+		if (D3DXAssembleShader (dest.c_str(), (UINT)dest.size(), NULL, NULL, 0, &pShader, &pErrorMsgs) == D3D_OK)
+		{
+			if (_DeviceInterface->CreateVertexShader((DWORD*)pShader->GetBufferPointer(), &(getVertexProgramD3D(*program)->Shader)) != D3D_OK)
+				return false;
+		}
+		else
+		{
+			nlwarning ("Can't assemble vertex 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;
 
-	// Setup or unsetup ?
-	if (program)
-	{
-		// Program setuped ?
-		if (program->_DrvInfo==NULL)
-		{
-			_VtxPrgDrvInfos.push_front (NULL);
-			ItVtxPrgDrvInfoPtrList itTex = _VtxPrgDrvInfos.begin();
-			*itTex = new CVertexProgamDrvInfosD3D(this, itTex);
-
-			// Create a driver info structure
-			program->_DrvInfo = *itTex;
-
-			/** 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);
-			if (!result)
-			{
-				nlwarning("Unable to parse a vertex program :");
-				nlwarning(errorOutput.c_str());
-				#ifdef NL_DEBUG_D3D
-					nlassert(0);
-				#endif // NL_DEBUG_D3D
-				return false;
-			}
-
-			// tmp fix for Radeon 8500/9000/9200
-			// Currently they hang when PaletteSkin / SkinWeight are present in the vertex declaration, but not used
-			// so disable them in the vertex declaration
-			// We don't use these component in vertex programs currently..
-			#ifdef NL_DEBUG
-				for(uint k = 0; k < parsedProgram.size(); ++k)
-				{
-					for(uint l = 0; l < parsedProgram[k].getNumUsedSrc(); ++l)
-					{
-						const CVPOperand &op = parsedProgram[k].getSrc(l);
-						if (op.Type == CVPOperand::InputRegister)
-						{
-							nlassert(op.Value.InputRegisterValue != CVPOperand::IWeight);
-							nlassert(op.Value.InputRegisterValue != CVPOperand::IPaletteSkin);
-						}
-					}
-				}
-			#endif
-
-			// Dump the vertex program
-			std::string dest;
-			dump(parsedProgram, dest);
-#ifdef NL_DEBUG_D3D
-			nlinfo("Assemble Vertex Shader : ");
-			string::size_type lineBegin = 0;
-			string::size_type lineEnd;
-			while ((lineEnd = dest.find('\n', lineBegin)) != string::npos)
-			{
-				nlinfo(dest.substr (lineBegin, lineEnd-lineBegin).c_str());
-				lineBegin = lineEnd+1;
-			}
-			nlinfo(dest.substr (lineBegin, lineEnd-lineBegin).c_str());
-#endif // NL_DEBUG_D3D
-
-			LPD3DXBUFFER pShader;
-			LPD3DXBUFFER pErrorMsgs;
-			if (D3DXAssembleShader (dest.c_str(), (UINT)dest.size(), NULL, NULL, 0, &pShader, &pErrorMsgs) == D3D_OK)
-			{
-				if (_DeviceInterface->CreateVertexShader((DWORD*)pShader->GetBufferPointer(), &(getVertexProgramD3D(*program)->Shader)) != D3D_OK)
-					return false;
-			}
-			else
-			{
-				nlwarning ("Can't assemble vertex program:");
-				nlwarning ((const char*)pErrorMsgs->GetBufferPointer());
-				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;
 }
@@ -1488,7 +1499,10 @@ void			CDriverGL::enableUsedTextureMemorySum (bool enable)
 	H_AUTO_OGL(CDriverGL_enableUsedTextureMemorySum )
 
 	if (enable)
+	{	
 		nlinfo ("3D: PERFORMANCE INFO: enableUsedTextureMemorySum has been set to true in CDriverGL");
+		_TextureUsed.reserve(512);
+	}
 	_SumTextureMemoryUsed=enable;
 }
 
@@ -1502,7 +1516,7 @@ uint32			CDriverGL::getUsedTextureMemory() const
 	uint32 memory=0;
 
 	// For each texture used
-	set<CTextureDrvInfosGL*>::const_iterator ite=_TextureUsed.begin();
+	std::vector<CTextureDrvInfosGL *>::const_iterator ite = _TextureUsed.begin();
 	while (ite!=_TextureUsed.end())
 	{
 		// Get the gl texture
@@ -1510,7 +1524,8 @@ uint32			CDriverGL::getUsedTextureMemory() const
 		gltext= (*ite);
 
 		// Sum the memory used by this texture
-		memory+=gltext->TextureMemory;
+		if (gltext)
+			memory+=gltext->TextureMemory;
 
 		// Next texture
 		ite++;
@@ -1531,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;
 
@@ -1543,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)
 	{
@@ -1983,12 +1998,6 @@ static void fetchPerturbedEnvMapR200()
 #endif
 }
 
-// ***************************************************************************
-void CDriverGL::forceNativeFragmentPrograms(bool nativeOnly)
-{
-	_ForceNativeFragmentPrograms = nativeOnly;
-}
-
 // ***************************************************************************
 void CDriverGL::initFragmentShaders()
 {
@@ -2182,6 +2191,7 @@ void	CDriverGL::setSwapVBLInterval(uint interval)
 		res = nwglSwapIntervalEXT(_Interval) == TRUE;
 	}
 #elif defined(NL_OS_MAC)
+	[_ctx setValues:(GLint*)&interval forParameter:NSOpenGLCPSwapInterval];
 #elif defined(NL_OS_UNIX)
 	if (_win && _Extensions.GLXEXTSwapControl)
 	{
@@ -2242,6 +2252,8 @@ void	CDriverGL::enablePolygonSmoothing(bool smooth)
 {
 	H_AUTO_OGL(CDriverGL_enablePolygonSmoothing);
 
+	if (_PolygonSmooth == smooth) return;
+
 #ifndef USE_OPENGLES
 	if(smooth)
 		glEnable(GL_POLYGON_SMOOTH);
@@ -2563,14 +2575,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"
@@ -196,6 +195,8 @@ public:
 
 	bool					initFrameBufferObject(ITexture * tex);
 	bool					activeFrameBufferObject(ITexture * tex);
+
+	std::vector<CTextureDrvInfosGL *>::size_type TextureUsedIdx;
 };
 
 
@@ -306,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();
 
@@ -368,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);
 
@@ -403,8 +403,6 @@ public:
 
 	virtual CMatrix			getViewMatrix() const;
 
-	virtual bool			activeShader(CShader *shd);
-
 	virtual	void			forceNormalize(bool normalize)
 	{
 		_ForceNormalize= normalize;
@@ -563,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);
 
@@ -600,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]);
 	// @}
@@ -692,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.
@@ -887,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
@@ -1273,7 +1274,7 @@ private:
 	uint32												_NbSetupMaterialCall;
 	uint32												_NbSetupModelMatrixCall;
 	bool												_SumTextureMemoryUsed;
-	std::set<CTextureDrvInfosGL*>						_TextureUsed;
+	std::vector<CTextureDrvInfosGL *>					_TextureUsed;
 	uint							computeMipMapMemoryUsage(uint w, uint h, GLint glfmt) const;
 
 	// VBHard Lock Profiling
@@ -1298,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
 	// @{
@@ -1341,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;
@@ -1494,7 +1627,7 @@ private:
 };
 
 // ***************************************************************************
-class CVertexProgamDrvInfosGL : public IVertexProgramDrvInfos
+class CVertexProgamDrvInfosGL : public IProgramDrvInfos
 {
 public:
 	// The GL Id.
@@ -1515,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

@@ -79,6 +79,8 @@ CTextureDrvInfosGL::CTextureDrvInfosGL(IDriver *drv, ItTexDrvInfoPtrMap it, CDri
 	InitFBO = false;
 	AttachDepthStencil = true;
 	UsePackedDepthStencil = drvGl->supportPackedDepthStencil();
+
+	TextureUsedIdx = 0;
 }
 // ***************************************************************************
 CTextureDrvInfosGL::~CTextureDrvInfosGL()
@@ -91,7 +93,10 @@ CTextureDrvInfosGL::~CTextureDrvInfosGL()
 	_Driver->_AllocatedTextureMemory-= TextureMemory;
 
 	// release in TextureUsed.
-	_Driver->_TextureUsed.erase (this);
+	if (TextureUsedIdx < _Driver->_TextureUsed.size() && _Driver->_TextureUsed[TextureUsedIdx] == this)
+	{
+		_Driver->_TextureUsed[TextureUsedIdx] = NULL;
+	}
 
 	if(InitFBO)
 	{
@@ -1492,7 +1497,11 @@ bool CDriverGL::activateTexture(uint stage, ITexture *tex)
 			if (_SumTextureMemoryUsed)
 			{
 				// Insert the pointer of this texture
-				_TextureUsed.insert (gltext);
+				if (gltext->TextureUsedIdx >= _TextureUsed.size() || _TextureUsed[gltext->TextureUsedIdx] != gltext)
+				{
+					gltext->TextureUsedIdx = _TextureUsed.size();
+					_TextureUsed.push_back(gltext);
+				}
 			}
 
 			if(tex->isTextureCube())
@@ -2314,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);
 		}
@@ -2334,7 +2343,7 @@ bool CDriverGL::setRenderTarget (ITexture *tex, uint32 x, uint32 y, uint32 width
 		setupViewport(_OldViewport);
 		_OldViewport = _CurrViewport;
 
-		_RenderTargetFBO = false;
+		_RenderTargetFBO = NULL;
 		return false;
 	}
 
@@ -2347,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,23 +70,136 @@ 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);
 }
 
 // ***************************************************************************
-bool CDriverGL::isVertexProgramEmulated () const
+bool CDriverGL::isVertexProgramEmulated() const
 {
 	H_AUTO_OGL(CVertexProgamDrvInfosGL_isVertexProgramEmulated)
 	return _Extensions.NVVertexProgramEmulated;
 }
 
+bool CDriverGL::compileNVVertexProgram(CVertexProgram *program)
+{
+	H_AUTO_OGL(CDriverGL_compileNVVertexProgram);
 
+#ifndef USE_OPENGLES
+
+	// Driver info
+	CVertexProgamDrvInfosGL *drvInfo;
+
+	nlassert(!program->m_DrvInfo);
+	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(source->SourcePtr, parsedProgram, errorOutput);
+	if (!result)
+	{
+		nlwarning("Unable to parse a vertex program :");
+		nlwarning(errorOutput.c_str());
+		#ifdef NL_DEBUG
+			nlassert(0);
+		#endif
+		return 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
+	*it = drvInfo = new CVertexProgamDrvInfosGL(this, it);
+
+	// Set the pointer
+	program->m_DrvInfo = drvInfo;
+
+	// Compile the program
+	nglLoadProgramNV(GL_VERTEX_PROGRAM_NV, drvInfo->ID, (GLsizei)source->SourceLen, (const GLubyte*)source->SourcePtr);
+
+	// Get loading error code
+	GLint errorOff;
+	glGetIntegerv(GL_PROGRAM_ERROR_POSITION_NV, &errorOff);
+
+	// Compilation error ?
+	if (errorOff >= 0)
+	{
+		// String length
+		uint length = (uint)source->SourceLen;
+		const char* sString = source->SourcePtr;
+
+		// Line count and char count
+		uint line=1;
+		uint charC=1;
+
+		// Find the line
+		uint offset=0;
+		while ((offset < length) && (offset < (uint)errorOff))
+		{
+			if (sString[offset]=='\n')
+			{
+				line++;
+				charC=1;
+			}
+			else
+				charC++;
+
+			// Next character
+			offset++;
+		}
+
+		// Show the error
+		nlwarning("3D: Vertex program syntax error line %d character %d\n", line, charC);
+
+		// 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
+}
 
 // ***************************************************************************
-bool CDriverGL::activeNVVertexProgram (CVertexProgram *program)
+bool CDriverGL::activeNVVertexProgram(CVertexProgram *program)
 {
 	H_AUTO_OGL(CVertexProgamDrvInfosGL_activeNVVertexProgram);
 
@@ -94,99 +207,16 @@ bool CDriverGL::activeNVVertexProgram (CVertexProgram *program)
 	// Setup or unsetup ?
 	if (program)
 	{
-		// Enable vertex program
-		glEnable (GL_VERTEX_PROGRAM_NV);
-		_VertexProgramEnabled= true;
-
-
 		// Driver info
-		CVertexProgamDrvInfosGL *drvInfo;
+		CVertexProgamDrvInfosGL *drvInfo = safe_cast<CVertexProgamDrvInfosGL*>((IProgramDrvInfos*)program->m_DrvInfo);
+		nlassert(drvInfo);
 
-		// Program setuped ?
+		// Enable vertex program
-		if (program->_DrvInfo==NULL)
+		glEnable(GL_VERTEX_PROGRAM_NV);
-		{
+		_VertexProgramEnabled = true;
-			/** 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);
-			if (!result)
-			{
-				nlwarning("Unable to parse a vertex program :");
-				nlwarning(errorOutput.c_str());
-				#ifdef NL_DEBUG
-					nlassert(0);
-				#endif
-				return false;
-			}
-
-			// Insert into driver list. (so it is deleted when driver is deleted).
-			ItVtxPrgDrvInfoPtrList	it= _VtxPrgDrvInfos.insert(_VtxPrgDrvInfos.end(), (NL3D::IVertexProgramDrvInfos*)NULL);
-
-			// Create a driver info
-			*it = drvInfo = new CVertexProgamDrvInfosGL (this, it);
-
-			// Set the pointer
-			program->_DrvInfo=drvInfo;
-
-			// Compile the program
-			nglLoadProgramNV (GL_VERTEX_PROGRAM_NV, drvInfo->ID, (GLsizei)program->getProgram().length(), (const GLubyte*)program->getProgram().c_str());
-
-			// Get loading error code
-			GLint errorOff;
-			glGetIntegerv (GL_PROGRAM_ERROR_POSITION_NV, &errorOff);
-
-			// Compilation error ?
-			if (errorOff>=0)
-			{
-				// String length
-				uint length = (uint)program->getProgram ().length();
-				const char* sString= program->getProgram ().c_str();
-
-				// Line count and char count
-				uint line=1;
-				uint charC=1;
-
-				// Find the line
-				uint offset=0;
-				while ((offset<length)&&(offset<(uint)errorOff))
-				{
-					if (sString[offset]=='\n')
-					{
-						line++;
-						charC=1;
-					}
-					else
-						charC++;
-
-					// Next character
-					offset++;
-				}
-
-				// 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
-				return false;
-			}
-
-			// Setup ok
-			return true;
-		}
-		else
-		{
-			// Cast the driver info pointer
-			drvInfo=safe_cast<CVertexProgamDrvInfosGL*>((IVertexProgramDrvInfos*)program->_DrvInfo);
-		}
 
 		// Setup this program
-		nglBindProgramNV (GL_VERTEX_PROGRAM_NV, drvInfo->ID);
+		nglBindProgramNV(GL_VERTEX_PROGRAM_NV, drvInfo->ID);
 		_LastSetuppedVP = program;
 
 		// Ok
@@ -195,8 +225,8 @@ bool CDriverGL::activeNVVertexProgram (CVertexProgram *program)
 	else // Unsetup
 	{
 		// Disable vertex program
-		glDisable (GL_VERTEX_PROGRAM_NV);
+		glDisable(GL_VERTEX_PROGRAM_NV);
-		_VertexProgramEnabled= false;
+		_VertexProgramEnabled = false;
 		// Ok
 		return true;
 	}
@@ -1486,165 +1516,273 @@ bool CDriverGL::setupARBVertexProgram (const CVPParser::TProgram &inParsedProgra
 #endif
 }
 
+// ***************************************************************************
 
+bool CDriverGL::compileARBVertexProgram(NL3D::CVertexProgram *program)
+{
+	H_AUTO_OGL(CDriverGL_compileARBVertexProgram);
+
+#ifndef USE_OPENGLES
+
+	nlassert(!program->m_DrvInfo);
+	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(source->SourcePtr, parsedProgram, errorOutput);
+	if (!result)
+	{
+		nlwarning("Unable to parse a vertex program.");
+		#ifdef NL_DEBUG
+			nlerror(errorOutput.c_str());
+		#endif
+		return 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
+	CVertexProgamDrvInfosGL *drvInfo;
+	*it = drvInfo = new CVertexProgamDrvInfosGL(this, it);
+	// Set the pointer
+	program->m_DrvInfo = drvInfo;
+
+	if (!setupARBVertexProgram(parsedProgram, drvInfo->ID, drvInfo->SpecularWritten))
+	{
+		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);
+
+	return true;
+
+#else
+
+	return false;
+
+#endif
+}
 
 // ***************************************************************************
-bool CDriverGL::activeARBVertexProgram (CVertexProgram *program)
+
+bool CDriverGL::activeARBVertexProgram(CVertexProgram *program)
 {
 	H_AUTO_OGL(CDriverGL_activeARBVertexProgram);
 
 #ifndef USE_OPENGLES
+
 	// Setup or unsetup ?
 	if (program)
 	{
 		// Driver info
-		CVertexProgamDrvInfosGL *drvInfo;
+		CVertexProgamDrvInfosGL *drvInfo = safe_cast<CVertexProgamDrvInfosGL*>((IProgramDrvInfos*)program->m_DrvInfo);
+		nlassert(drvInfo);
 
-		// Program setuped ?
-		if (program->_DrvInfo==NULL)
-		{
-			// try to parse the program
-			CVPParser parser;
-			CVPParser::TProgram parsedProgram;
-			std::string errorOutput;
-			bool result = parser.parse(program->getProgram().c_str(), parsedProgram, errorOutput);
-			if (!result)
-			{
-				nlwarning("Unable to parse a vertex program.");
-				#ifdef NL_DEBUG
-					nlerror(errorOutput.c_str());
-				#endif
-				return false;
-			}
-			// Insert into driver list. (so it is deleted when driver is deleted).
-			ItVtxPrgDrvInfoPtrList	it= _VtxPrgDrvInfos.insert(_VtxPrgDrvInfos.end(), (NL3D::IVertexProgramDrvInfos*)NULL);
-
-			// Create a driver info
-			*it = drvInfo = new CVertexProgamDrvInfosGL (this, it);
-			// Set the pointer
-			program->_DrvInfo=drvInfo;
-
-			if (!setupARBVertexProgram(parsedProgram, drvInfo->ID, drvInfo->SpecularWritten))
-			{
-				delete drvInfo;
-				program->_DrvInfo = NULL;
-				_VtxPrgDrvInfos.erase(it);
-				return false;
-			}
-		}
-		else
-		{
-			// Cast the driver info pointer
-			drvInfo=safe_cast<CVertexProgamDrvInfosGL*>((IVertexProgramDrvInfos*)program->_DrvInfo);
-		}
 		glEnable( GL_VERTEX_PROGRAM_ARB );
 		_VertexProgramEnabled = true;
-		nglBindProgramARB( GL_VERTEX_PROGRAM_ARB, drvInfo->ID );
+		nglBindProgramARB(GL_VERTEX_PROGRAM_ARB, drvInfo->ID);
 		if (drvInfo->SpecularWritten)
 		{
-			glEnable( GL_COLOR_SUM_ARB );
+			glEnable(GL_COLOR_SUM_ARB);
 		}
 		else
 		{
-			glDisable( GL_COLOR_SUM_ARB ); // no specular written
+			glDisable(GL_COLOR_SUM_ARB); // no specular written
 		}
 		_LastSetuppedVP = program;
 	}
 	else
 	{
-		glDisable( GL_VERTEX_PROGRAM_ARB );
+		glDisable(GL_VERTEX_PROGRAM_ARB);
-		glDisable( GL_COLOR_SUM_ARB );
+		glDisable(GL_COLOR_SUM_ARB);
 		_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)
+	nlassert(program->m_DrvInfo);
+	glDisable(GL_VERTEX_SHADER_EXT);
+	_VertexProgramEnabled = false;
+
+	// Find nelvp
+	IProgram::CSource *source = NULL;
+	for (uint i = 0; i < program->getSourceNb(); ++i)
 	{
-		// Driver info
+		if (program->getSource(i)->Profile == CVertexProgram::nelvp)
-		CVertexProgamDrvInfosGL *drvInfo;
-
-		// Program setuped ?
-		if (program->_DrvInfo==NULL)
 		{
-			// try to parse the program
+			source = program->getSource(i);
-			CVPParser parser;
-			CVPParser::TProgram parsedProgram;
-			std::string errorOutput;
-			bool result = parser.parse(program->getProgram().c_str(), parsedProgram, errorOutput);
-			if (!result)
-			{
-				nlwarning("Unable to parse a vertex program.");
-				#ifdef NL_DEBUG
-					nlerror(errorOutput.c_str());
-				#endif
-				return false;
-			}
-
-			/*
-			FILE *f = fopen(getLogDirectory() + "test.txt", "wb");
-			if (f)
-			{
-				std::string vpText;
-				CVPParser::dump(parsedProgram, vpText);
-				fwrite(vpText.c_str(), vpText.size(), 1, f);
-				fclose(f);
-			}
-			*/
-
-			// Insert into driver list. (so it is deleted when driver is deleted).
-			ItVtxPrgDrvInfoPtrList	it= _VtxPrgDrvInfos.insert(_VtxPrgDrvInfos.end(), (NL3D::IVertexProgramDrvInfos*)NULL);
-
-			// Create a driver info
-			*it = drvInfo = new CVertexProgamDrvInfosGL (this, it);
-			// Set the pointer
-			program->_DrvInfo=drvInfo;
-
-			if (!setupEXTVertexShader(parsedProgram, drvInfo->ID, drvInfo->Variants, drvInfo->UsedVertexComponents))
-			{
-				delete drvInfo;
-				program->_DrvInfo = NULL;
-				_VtxPrgDrvInfos.erase(it);
-				return false;
-			}
 		}
-		else
-		{
-			// Cast the driver info pointer
-			drvInfo=safe_cast<CVertexProgamDrvInfosGL*>((IVertexProgramDrvInfos*)program->_DrvInfo);
-		}
-
-		glEnable( GL_VERTEX_SHADER_EXT);
-		_VertexProgramEnabled = true;
-		nglBindVertexShaderEXT( drvInfo->ID );
-		_LastSetuppedVP = program;
 	}
-	else
+	if (!source)
 	{
-		glDisable( GL_VERTEX_SHADER_EXT );
+		nlwarning("OpenGL driver only supports 'nelvp' profile, vertex program cannot be used");
-		_VertexProgramEnabled = false;
+		return false;
 	}
+
+	// try to parse the program
+	CVPParser parser;
+	CVPParser::TProgram parsedProgram;
+	std::string errorOutput;
+	bool result = parser.parse(source->SourcePtr, parsedProgram, errorOutput);
+	if (!result)
+	{
+		nlwarning("Unable to parse a vertex program.");
+		#ifdef NL_DEBUG
+			nlerror(errorOutput.c_str());
+		#endif
+		return false;
+	}
+
+	/*
+	FILE *f = fopen(getLogDirectory() + "test.txt", "wb");
+	if (f)
+	{
+		std::string vpText;
+		CVPParser::dump(parsedProgram, vpText);
+		fwrite(vpText.c_str(), vpText.size(), 1, f);
+		fclose(f);
+	}
+	*/
+
+	// 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
+	CVertexProgamDrvInfosGL *drvInfo;
+	*it = drvInfo = new CVertexProgamDrvInfosGL (this, it);
+	// Set the pointer
+	program->m_DrvInfo=drvInfo;
+
+	if (!setupEXTVertexShader(parsedProgram, drvInfo->ID, drvInfo->Variants, drvInfo->UsedVertexComponents))
+	{
+		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);
+
 	return true;
+
 #else
+
 	return false;
+
 #endif
 }
 
 // ***************************************************************************
-bool CDriverGL::activeVertexProgram (CVertexProgram *program)
+
+bool CDriverGL::activeEXTVertexShader(CVertexProgram *program)
+{
+	H_AUTO_OGL(CDriverGL_activeEXTVertexShader);
+
+#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;
+		nglBindVertexShaderEXT(drvInfo->ID);
+		_LastSetuppedVP = program;
+	}
+	else
+	{
+		glDisable(GL_VERTEX_SHADER_EXT);
+		_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/opengl/unix_event_emitter.cpp

@@ -23,6 +23,7 @@
 #include <X11/Xatom.h>
 #include <X11/keysym.h>
 #include <X11/Xutil.h>
+#include <X11/XKBlib.h> 
 #include "nel/misc/debug.h"
 
 
@@ -566,7 +567,7 @@ bool CUnixEventEmitter::processMessage (XEvent &event, CEventServer *server)
 		}
 		else
 		{
-			k = XKeycodeToKeysym(_dpy, keyCode, 0);
+			k = XkbKeycodeToKeysym(_dpy, keyCode, 0, 0);
 		}
 
 		// send CEventKeyDown event only if keyCode is defined

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

@@ -568,18 +568,21 @@ void			CLandscape::clear()
 void			CLandscape::setDriver(IDriver *drv)
 {
 	nlassert(drv);
-	if(_Driver != drv)
+	if (_Driver != drv)
 	{
 		_Driver= 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???
 		// only if VP supported by GPU, and Only if max vertices allowed.
-		_DriverOkForVegetable= _VertexShaderOk && (_Driver->getMaxVerticesByVertexBufferHard()>=(uint)NL3D_LANDSCAPE_VEGETABLE_MAX_AGP_VERTEX_MAX);
+		_DriverOkForVegetable = _VertexShaderOk && (_Driver->getMaxVerticesByVertexBufferHard()>=(uint)NL3D_LANDSCAPE_VEGETABLE_MAX_AGP_VERTEX_MAX);
 
 	}
 }
@@ -1193,20 +1196,33 @@ void			CLandscape::render(const CVector &refineCenter, const CVector &frontVecto
 
 
 	// If VertexShader enabled, setup VertexProgram Constants.
-	if(_VertexShaderOk)
+	if (_VertexShaderOk)
 	{
-		// c[0..3] take the ModelViewProjection Matrix.
+		bool uprogstate = driver->isUniformProgramState();
-		driver->setConstantMatrix(0, IDriver::ModelViewProjection, IDriver::Identity);
+		uint nbvp = uprogstate ? CLandscapeVBAllocator::MaxVertexProgram : 1;
-		// c[4] take useful constants.
+		for (uint i = 0; i < nbvp; ++i)
-		driver->setConstant(4, 0, 1, 0.5f, 0);
+		{
-		// c[5] take RefineCenter
+			CVertexProgramLandscape *program = _TileVB.getVP(i);
-		driver->setConstant(5, refineCenter);
+			if (program)
-		// c[6] take info for Geomorph trnasition to TileNear.
+			{
-		driver->setConstant(6, CLandscapeGlobals::TileDistFarSqr, CLandscapeGlobals::OOTileDistDeltaSqr, 0, 0);
+				// activate the program to set the uniforms in the program state for all programs
-		// c[10] take the fog vector.
+				// note: when uniforms are driver state, the indices must be the same across programs
-		driver->setConstantFog(10);
+				_TileVB.activateVP(i);
-		// c[12] take the current landscape Center / delta Pos to apply
+
-		driver->setConstant(12, _PZBModelPosition);
+				// c[0..3] take the ModelViewProjection Matrix.
+				driver->setUniformMatrix(IDriver::VertexProgram, program->getUniformIndex(CProgramIndex::ModelViewProjection), IDriver::ModelViewProjection, IDriver::Identity);
+				// c[4] take useful constants.
+				driver->setUniform4f(IDriver::VertexProgram, program->idx().ProgramConstants0, 0, 1, 0.5f, 0);
+				// c[5] take RefineCenter
+				driver->setUniform3f(IDriver::VertexProgram, program->idx().RefineCenter, refineCenter);
+				// c[6] take info for Geomorph trnasition to TileNear.
+				driver->setUniform2f(IDriver::VertexProgram, program->idx().TileDist, CLandscapeGlobals::TileDistFarSqr, CLandscapeGlobals::OOTileDistDeltaSqr);
+				// c[10] take the fog vector.
+				driver->setUniformFog(IDriver::VertexProgram, program->getUniformIndex(CProgramIndex::Fog));
+				// c[12] take the current landscape Center / delta Pos to apply
+				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])
+	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])
+		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,34 +406,89 @@ 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 :)
+
+		// \todo yoyo TODO_OPTIM Manage different number of pointLights
+		// 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::getLightVPFragmentNeLVP(
+									m_FeaturesLighted.NumActivePointLights, 
+									m_FeaturesLighted.CtStartNeLVP, 
+									m_FeaturesLighted.SupportSpecular,  
+									m_FeaturesLighted.Normalize)
+							  + std::string("# ***************") // temp for debug
+							  + std::string(PPLightingVPCodeEnd);
+		#ifdef NL_DEBUG
+			/** For test : parse those programs before they are used.
+			  * As a matter of fact some program will works with the NV_VERTEX_PROGRAM extension,
+			  * but won't with EXT_vertex_shader, because there are some limitations (can't read a temp
+			  * register that hasn't been written before..)
+			  */
+			CVPParser			vpParser;
+			CVPParser::TProgram result;
+			std::string          parseOutput;
+			if (!vpParser.parse(vpCode.c_str(), result, parseOutput))
+			{
+				nlwarning(parseOutput.c_str());
+				nlassert(0);
+			}
+		#endif
+
+		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)
 		{
-			// \todo yoyo TODO_OPTIM Manage different number of pointLights
+			_VertexProgram[vp] = new CVertexProgramPerPixelLight(vp);
-			// NB: never call getLightVPFragment() 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)
-								  + std::string("# ***************") // temp for debug
-								  + std::string(PPLightingVPCodeEnd);
-			#ifdef NL_DEBUG
-				/** For test : parse those programs before they are used.
-				  * As a matter of fact some program will works with the NV_VERTEX_PROGRAM extension,
-				  * but won't with EXT_vertex_shader, because there are some limitations (can't read a temp
-				  * register that hasn't been written before..)
-				  */
-				CVPParser			vpParser;
-				CVPParser::TProgram result;
-				std::string          parseOutput;
-				if (!vpParser.parse(vpCode.c_str(), result, parseOutput))
-				{
-					nlwarning(parseOutput.c_str());
-					nlassert(0);
-				}
-			#endif
-			_VertexProgram[vp]= std::auto_ptr<CVertexProgram>(new CVertexProgram(vpCode.c_str()));
 		}
-
 	}
 }
 
@@ -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

@@ -35,11 +35,11 @@ namespace NL3D
 
 // ***************************************************************************
 // Light VP fragment constants start at 24
-static	const uint	VPLightConstantStart= 24;
+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,47 +474,71 @@ 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;
+	_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);
 
 	// Enable normalize only if requested by user. Because lighting don't manage correct "scale lighting"
-	uint	idVP= (SpecularLighting?2:0) + (driver->isForceNormalize()?1:0) ;
+	uint idVP = (SpecularLighting?2:0) + (driver->isForceNormalize()?1:0) ;
 	// correct VP id for correct number of pls.
-	idVP= numPls*4 + idVP;
+	idVP = numPls*4 + idVP;
 
 	// re-activate VP if idVP different from last setup
-	if( idVP!=_LastMBRIdVP )
+	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);
 }
 
 // ***************************************************************************
@@ -415,6 +546,7 @@ void	CMeshVPWindTree::endMBRMesh(IDriver *driver)
 {
 	// Disable the VertexProgram
 	driver->activeVertexProgram(NULL);
+	_ActiveVertexProgram = NULL;
 }
 
 // ***************************************************************************