Merge branch 'upstream/master' into perPlayerDifficulties

Conflicts:
	data/gui/options_ui.stkgui
	src/graphics/stkmesh.cpp
	src/states_screens/options_screen_ui.cpp

data/gui/main.stkgui

@@ -1,5 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <stkgui>
+    <div x="0" y="0" width="100%" height="fit" layout="vertical-row">
+        <button id="user-id" width="20%" height="fit" align="right"/>
+    </div>
+
     <div x="0" y="0" width="100%" height="100%" layout="vertical-row" >
         <icon id="logo" align="center" proportion="5" width="100%" icon="gui/logo.png"/>
 

data/gui/options_ui.stkgui

@@ -30,7 +30,7 @@
             <div layout="horizontal-row" width="100%" height="fit">
                 <div proportion="1" height="fit" layout="horizontal-row" >
                     <checkbox id="showfps"/>
-                    <spacer width="20" height="10" />
+                    <spacer width="20" height="100%" />
                     <label height="100%" I18N="In the ui settings" text="Display FPS"/>
                 </div>
 
@@ -38,13 +38,31 @@
 
                 <div layout="horizontal-row" proportion="1" height="fit">
                     <checkbox id="perPlayerDifficulty"/>
-                    <spacer width="20" height="10" />
+                    <spacer width="20" height="100%" />
                     <label I18N="In the ui settings" text="Enable handicaped users"/>
                 </div>
             </div>
 
             <spacer height="4" width="10" />
 
+            <div layout="horizontal-row" width="100%" height="fit">
+                <div width="75%" height="fit" layout="horizontal-row" >
+                    <checkbox id="show-login"/>
+                    <spacer width="20" height="100%" />
+                    <label height="100%" I18N="In the ui settings" text="Always show login screen"/>
+                </div>
+
+                <spacer height="4" width="10" />
+
+                <div layout="horizontal-row" proportion="1" height="fit">
+                    <checkbox id="aiHandicap"/>
+                    <spacer width="20" height="100%" />
+                    <label I18N="In the ui settings" text="Handicap AI karts"/>
+                </div>
+            </div>
+
+            <spacer height="4" width="10" />
+
             <div layout="horizontal-row" width="100%" height="fit">
                 <div proportion="1" height="fit" layout="horizontal-row" >
                     <checkbox id="enable-internet"/>
@@ -54,19 +72,14 @@
 
                 <spacer height="4" width="10" />
 
-                <div layout="horizontal-row" proportion="1" height="fit">
+                <div width="75%" height="fit" layout="horizontal-row" >
-                    <checkbox id="aiHandicap"/>
+                    <checkbox id="enable-hw-report"/>
-                    <spacer width="20" height="10" />
+                    <spacer width="20" height="100%" />
-                    <label I18N="In the ui settings" text="Handicap AI karts"/>
+                    <label id="label-hw-report" height="100%" I18N="In the ui settings"
+                           text="Allow STK to send anonymous HW statistics"/>
                 </div>
             </div>
 
-            <div width="75%" height="fit" layout="horizontal-row" >
-                <checkbox id="show-login"/>
-                <spacer width="20" height="100%" />
-                <label height="100%" I18N="In the ui settings" text="Always show login screen"/>
-            </div>
-
             <spacer height="18" width="4"/>
 
             <!-- ************ LANGUAGE CHOICE ************ -->

data/shaders/diffuseenvmap.frag

@@ -50,7 +50,9 @@ void main(void)
     sampleDirection = (InverseViewMatrix * vec4(sampleDirection, 0.)).xyz;
 
     float specval = texture(ntex, uv).z;
-    float lodval = 16 * (1. - ((log2(specval) - 1.) / 10.));
+    // From http://graphics.cs.williams.edu/papers/EnvMipReport2013/
+    int texSize = textureSize(tex, 0).x;
+    float lodval = clamp(log2(texSize * sqrt(3)) - .5 * log2(specval + 1), 0., 10.);
     vec4 specular = textureLod(tex, sampleDirection, lodval);
     Spec = max(specular, vec4(0.));
 }

lib/irrlicht/source/Irrlicht/CIrrDeviceWin32.cpp

@@ -16,6 +16,8 @@
 #include "COSOperator.h"
 #include "dimension2d.h"
 #include "IGUISpriteBank.h"
+#include <mmsystem.h>
+#include <regstr.h>
 #include <winuser.h>
 #if defined(_IRR_COMPILE_WITH_JOYSTICK_EVENTS_)
 #ifdef _IRR_COMPILE_WITH_DIRECTINPUT_JOYSTICK_
@@ -359,6 +361,63 @@ void pollJoysticks()
 #endif // _IRR_COMPILE_WITH_JOYSTICK_EVENTS_
 }
 
+/** This function is ported from SDL and released under zlip:
+ *  Copyright (C) 1997-2014 Sam Lantinga <slouken@libsdl.org>
+ */
+void setJoystickName(int index, const JOYCAPS &caps, SJoystickInfo *joystick)
+{
+    // As a default use the name given in the joystick structure
+    // - though that is always the same name, independent of joystick :(
+    joystick->Name = caps.szPname;
+
+    core::stringc key = core::stringc(REGSTR_PATH_JOYCONFIG)+"\\"+caps.szRegKey
+                      + "\\"+REGSTR_KEY_JOYCURR;
+    HKEY hTopKey = HKEY_LOCAL_MACHINE;
+    HKEY hKey;
+    long regresult = RegOpenKeyExA(hTopKey, key.c_str(), 0, KEY_READ, &hKey);
+    if (regresult != ERROR_SUCCESS)
+    {
+        hTopKey = HKEY_CURRENT_USER;
+        regresult = RegOpenKeyExA(hTopKey, key.c_str(), 0, KEY_READ, &hKey);
+    }
+    if (regresult != ERROR_SUCCESS) return;
+
+    /* find the registry key name for the joystick's properties */
+    char regname[256];
+    DWORD regsize = sizeof(regname);
+    core::stringc regvalue = core::stringc("Joystick")+core::stringc(index+1)
+                           + REGSTR_VAL_JOYOEMNAME;
+    regresult = RegQueryValueExA(hKey, regvalue.c_str(), 0, 0,
+                                 (LPBYTE)regname, &regsize);
+    RegCloseKey(hKey);
+    if (regresult != ERROR_SUCCESS) return;
+
+    /* open that registry key */
+    core::stringc regkey = core::stringc(REGSTR_PATH_JOYOEM)+"\\"+regname;
+    regresult = RegOpenKeyExA(hTopKey, regkey.c_str(), 0, KEY_READ, &hKey);
+    if (regresult != ERROR_SUCCESS) return;
+
+    /* find the size for the OEM name text */
+    regsize = sizeof(regvalue);
+    regresult = RegQueryValueExA(hKey, REGSTR_VAL_JOYOEMNAME, 0, 0,
+                                 NULL, &regsize);
+    if (regresult == ERROR_SUCCESS)
+    {
+        char *name;
+        /* allocate enough memory for the OEM name text ... */
+        name = new char[regsize];
+        if (name)
+        {
+            /* ... and read it from the registry */
+            regresult = RegQueryValueExA(hKey, REGSTR_VAL_JOYOEMNAME, 0, 0,
+                                         (LPBYTE)name, &regsize            );
+            joystick->Name = name;
+        }   // if name
+    }    // if SUCCESS
+    RegCloseKey(hKey);
+}
+
+
 bool activateJoysticks(core::array<SJoystickInfo> & joystickInfo)
 {
 #if defined _IRR_COMPILE_WITH_JOYSTICK_EVENTS_
@@ -407,11 +466,10 @@ bool activateJoysticks(core::array<SJoystickInfo> & joystickInfo)
 		{
 			activeJoystick.Index = joystick;
 			ActiveJoysticks.push_back(activeJoystick);
-
 			returnInfo.Joystick = (u8)joystick;
 			returnInfo.Axes = activeJoystick.Caps.wNumAxes;
 			returnInfo.Buttons = activeJoystick.Caps.wNumButtons;
-			returnInfo.Name = activeJoystick.Caps.szPname;
+			setJoystickName(joystick, activeJoystick.Caps, &returnInfo);
 			returnInfo.PovHat = ((activeJoystick.Caps.wCaps & JOYCAPS_HASPOV) == JOYCAPS_HASPOV)
 								? SJoystickInfo::POV_HAT_PRESENT : SJoystickInfo::POV_HAT_ABSENT;
 

sources.cmake

@@ -1,5 +1,5 @@
 # Modify this file to change the last-modified date when you add/remove a file. 
-# This will then trigger a new cmake run automatically. 
+# This will then trigger a new cmake run automatically.  
 file(GLOB_RECURSE STK_HEADERS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "src/*.hpp")
 file(GLOB_RECURSE STK_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "src/*.cpp")
 file(GLOB_RECURSE STK_SHADERS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "data/shaders/*")

src/achievements/achievement.cpp

@@ -24,7 +24,6 @@
 #include "guiengine/message_queue.hpp"
 #include "io/utf_writer.hpp"
 #include "config/player_manager.hpp"
-#include "states_screens/dialogs/notification_dialog.hpp"
 #include "utils/log.hpp"
 #include "utils/translation.hpp"
 

src/audio/dummy_sfx.hpp

@@ -55,6 +55,8 @@ public:
     virtual void       reallySetSpeed(float factor)     {}
     virtual void       setVolume(float gain)            {}
     virtual void       reallySetVolume(float gain)      {}
+    virtual void       setMasterVolume(float gain)      {}
+    virtual void       reallySetMasterVolumeNow(float gain) {}
     virtual SFXStatus  getStatus()                      { return SFX_STOPPED; }
     virtual void       onSoundEnabledBack()             {}
     virtual void       setRolloff(float rolloff)        {}

src/audio/sfx_base.hpp

@@ -52,31 +52,32 @@ public:
     virtual           ~SFXBase()  {}
 
     /** Late creation, if SFX was initially disabled */
-    virtual bool       init()                           = 0;
+    virtual bool       init()                               = 0;
-    virtual bool       isLooped()                       = 0;
+    virtual bool       isLooped()                           = 0;
-    virtual void       updatePlayingSFX(float dt)       = 0;
+    virtual void       updatePlayingSFX(float dt)           = 0;
-    virtual void       setPosition(const Vec3 &p)       = 0;
+    virtual void       setPosition(const Vec3 &p)           = 0;
-    virtual void       reallySetPosition(const Vec3 &p) = 0;
+    virtual void       reallySetPosition(const Vec3 &p)     = 0;
-    virtual void       setLoop(bool status)             = 0;
+    virtual void       setLoop(bool status)                 = 0;
-    virtual void       reallySetLoop(bool status)       = 0;
+    virtual void       reallySetLoop(bool status)           = 0;
-    virtual void       play()                           = 0;
+    virtual void       play()                               = 0;
-    virtual void       reallyPlayNow()                  = 0;
+    virtual void       reallyPlayNow()                      = 0;
-    virtual void       stop()                           = 0;
+    virtual void       stop()                               = 0;
-    virtual void       reallyStopNow()                  = 0;
+    virtual void       reallyStopNow()                      = 0;
-    virtual void       pause()                          = 0;
+    virtual void       pause()                              = 0;
-    virtual void       reallyPauseNow()                 = 0;
+    virtual void       reallyPauseNow()                     = 0;
-    virtual void       resume()                         = 0;
+    virtual void       resume()                             = 0;
-    virtual void       reallyResumeNow()                = 0;
+    virtual void       reallyResumeNow()                    = 0;
-    virtual void       deleteSFX()                      = 0;
+    virtual void       deleteSFX()                          = 0;
-    virtual void       setSpeed(float factor)           = 0;
+    virtual void       setSpeed(float factor)               = 0;
-    virtual void       reallySetSpeed(float factor)     = 0;
+    virtual void       reallySetSpeed(float factor)         = 0;
-    virtual void       setVolume(float gain)            = 0;
+    virtual void       setVolume(float gain)                = 0;
-    virtual void       reallySetVolume(float gain)      = 0;
+    virtual void       reallySetVolume(float gain)          = 0;
-    virtual void       setMasterVolume(float gain)      = 0;
+    virtual void       setMasterVolume(float gain)          = 0;
-    virtual void       onSoundEnabledBack()             = 0;
+    virtual void       reallySetMasterVolumeNow(float gain) = 0;
-    virtual void       setRolloff(float rolloff)        = 0;
+    virtual void       onSoundEnabledBack()                 = 0;
-    virtual const SFXBuffer* getBuffer() const          = 0;
+    virtual void       setRolloff(float rolloff)            = 0;
-    virtual SFXStatus  getStatus()                      = 0;
+    virtual const SFXBuffer* getBuffer() const              = 0;
+    virtual SFXStatus  getStatus()                          = 0;
 
 };   // SFXBase
 

src/audio/sfx_manager.cpp

@@ -287,6 +287,9 @@ void* SFXManager::mainLoop(void *obj)
                                          current->m_parameter); break;
         case SFX_VOLUME:   current->m_sfx->reallySetVolume(
                                   current->m_parameter.getX()); break;
+        case SFX_MASTER_VOLUME: 
+                           current->m_sfx->reallySetMasterVolumeNow(
+                                  current->m_parameter.getX()); break;
         case SFX_LOOP:     current->m_sfx->reallySetLoop(
                                current->m_parameter.getX()!=0); break;
         case SFX_DELETE:   {
@@ -318,7 +321,7 @@ void* SFXManager::mainLoop(void *obj)
  *  resumes all sound effects. 
  *  \param on If sound is switched on or off.
  */
-void SFXManager::soundToggled(const bool on)
+void SFXManager::toggleSound(const bool on)
 {
     // When activating SFX, load all buffers
     if (on)
@@ -330,7 +333,7 @@ void SFXManager::soundToggled(const bool on)
             buffer->load();
         }
 
-        resumeAll();
+        reallyResumeAllNow();
         m_all_sfx.lock();
         const int sfx_amount = (int)m_all_sfx.getData().size();
         for (int n=0; n<sfx_amount; n++)
@@ -354,7 +357,7 @@ void SFXManager::soundToggled(const bool on)
         m_all_sfx.unlock();
         pauseAll();
     }
-}   // soundToggled
+}   // toggleSound
 
 //----------------------------------------------------------------------------
 /** Returns if sfx can be played. This means sfx are enabled and
@@ -811,15 +814,15 @@ void SFXManager::reallyPositionListenerNow()
         float orientation[6];
         orientation[0] = m_listener_front.getX();
         orientation[1] = m_listener_front.getY();
-        orientation[2] = m_listener_front.getZ();
+        orientation[2] = -m_listener_front.getZ();
 
         //up vector
         orientation[3] = m_listener_up.getX();
         orientation[4] = m_listener_up.getY();
-        orientation[5] = m_listener_up.getZ();
+        orientation[5] = -m_listener_up.getZ();
 
         const Vec3 &pos = m_listener_position.getData();
-        alListener3f(AL_POSITION, pos.getX(), pos.getY(), pos.getZ());
+        alListener3f(AL_POSITION, pos.getX(), pos.getY(), -pos.getZ());
         alListenerfv(AL_ORIENTATION, orientation);
     }
     m_listener_position.unlock();

src/audio/sfx_manager.hpp

@@ -72,6 +72,7 @@ public:
         SFX_SPEED,
         SFX_POSITION,
         SFX_VOLUME,
+        SFX_MASTER_VOLUME,
         SFX_LOOP,
         SFX_LISTENER,
         SFX_UPDATE,
@@ -233,7 +234,7 @@ public:
     SFXBase*                 quickSound(const std::string &soundName);
 
     /** Called when sound was muted/unmuted */
-    void                     soundToggled(const bool newValue);
+    void                     toggleSound(const bool newValue);
 
     // ------------------------------------------------------------------------
     /** Prints the list of currently loaded sounds to stdout. Useful to

src/audio/sfx_openal.cpp

@@ -208,30 +208,40 @@ void SFXOpenAL::reallySetVolume(float gain)
 }   // reallySetVolume
 
 //-----------------------------------------------------------------------------
-
+/** Schedules setting of the master volume.
+ *  \param gain Gain value.
+ */
 void SFXOpenAL::setMasterVolume(float gain)
+{
+    // This needs to be called even if sfx are disabled atm, so only exit
+    // in case that the sfx could not be loaded in the first place.
+    if(m_status==SFX_UNKNOWN) return;
+    SFXManager::get()->queue(SFXManager::SFX_MASTER_VOLUME, this, gain);
+}   // setMasterVolume
+
+//-----------------------------------------------------------------------------
+/** Sets the master volume.
+ *  \param gain Master volume.
+ */
+void SFXOpenAL::reallySetMasterVolumeNow(float gain)
 {
     m_master_gain = gain;
     
-    if(m_status==SFX_UNKNOWN) return;
+    if(m_status==SFX_UNKNOWN || m_status == SFX_NOT_INITIALISED) return;
-    if(m_status==SFX_NOT_INITIALISED)
-    {
-        init();
-        if(m_status==SFX_UNKNOWN)
-            return;
-    }
-
 
     alSourcef(m_sound_source, AL_GAIN, 
                (m_gain < 0.0f ? m_default_gain : m_gain) * m_master_gain);
     SFXManager::checkError("setting volume");
-}   //setMasterVolume
+}   // reallySetMasterVolumeNow
 
 //-----------------------------------------------------------------------------
 /** Loops this sound effect.
  */
 void SFXOpenAL::setLoop(bool status)
 {
+    // Set the flag (even if sfx are disabled), so that the right settings
+    // are available on restart.
+    m_loop = status;
     if (m_status == SFX_UNKNOWN || !SFXManager::get()->sfxAllowed()) return;
     SFXManager::get()->queue(SFXManager::SFX_LOOP, this, status ? 1.0f : 0.0f);
 }   // setLoop
@@ -247,7 +257,6 @@ void SFXOpenAL::reallySetLoop(bool status)
         if(m_status==SFX_UNKNOWN)
             return;
     }
-    m_loop = status;
 
     alSourcei(m_sound_source, AL_LOOPING, status ? AL_TRUE : AL_FALSE);
     SFXManager::checkError("looping");
@@ -403,8 +412,8 @@ void SFXOpenAL::reallySetPosition(const Vec3 &position)
         return;
     }
 
-    alSource3f(m_sound_source, AL_POSITION, (float)position.getX(),
+    alSource3f(m_sound_source, AL_POSITION, position.getX(),
-               (float)position.getY(), (float)position.getZ());
+               position.getY(), -position.getZ());
 
     if (SFXManager::get()->getListenerPos().distance(position) 
         > m_sound_buffer->getMaxDist())

src/audio/sfx_openal.hpp

@@ -100,6 +100,7 @@ public:
     virtual void      setVolume(float gain);
     virtual void      reallySetVolume(float gain);
     virtual void      setMasterVolume(float gain);
+    virtual void      reallySetMasterVolumeNow(float gain);
     virtual void      onSoundEnabledBack();
     virtual void      setRolloff(float rolloff);
     // ------------------------------------------------------------------------

src/config/device_config.cpp

@@ -16,11 +16,16 @@
 //  along with this program; if not, write to the Free Software
 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
-#include <assert.h>
 
 #include "config/device_config.hpp"
+
+#include "io/xml_node.hpp"
 #include "utils/log.hpp"
+
 #include <SKeyMap.h>
+
+#include <assert.h>
+
 using namespace irr;
 
 //==== D E V I C E C O N F I G =================================================
@@ -223,39 +228,51 @@ void DeviceConfig::serialize (std::ofstream& stream)
 }   // serialize
 
 //------------------------------------------------------------------------------
-
+/** Reads a device configuration from input.xml.
-bool DeviceConfig::deserializeAction(irr::io::IrrXMLReader* xml)
+ *  \param config The XML Node of the configuration.
+ *  \return False if an error occurred.
+ */
+bool DeviceConfig::load(const XMLNode *config)
 {
-    int                  binding_id = -1;
+    bool error = false;
-
+    for(unsigned int i=0; i<config->getNumNodes(); i++)
-    // Never hurts to check ;)
-    if (xml == NULL)
     {
-        Log::error("DeviceConfig", "Null pointer (DeviceConfig::deserializeAction)");
+        const XMLNode *action = config->getNode(i);
-        return false;
+        if(action->getName()!="action")
-    }
-
-    // Read tags from XML
-    const char *name_string     = xml->getAttributeValue("name");
-    // Try to determine action # for verbose action name
-    for (int i = 0; i < PA_COUNT; i++)
-    {
-        if (strcmp(name_string, KartActionStrings[i].c_str()) == 0)
         {
-            binding_id = i;
+            Log::warn("DeviceConfig", "Invalid configuration '%s' - ignored.");
-            break;
+            continue;
+        }
+        std::string name;
+        action->get("name", &name);
+        int binding_id = -1;
+        for (int i = 0; i < PA_COUNT; i++)
+        {
+            if (name==KartActionStrings[i])
+            {
+                binding_id = i;
+                break;
+            }
+        }
+        if (binding_id == -1)
+        {
+            Log::warn("DeviceConfig",
+                      "DeviceConfig::deserializeAction : action '%s' is unknown.",
+                      name.c_str());
+            error=true;
         }
-    }
-    if(binding_id==-1)
-    {
-        Log::warn("DeviceConfig", "DeviceConfig::deserializeAction : action '%s' is unknown.",
-                  name_string);
-        return false;
-    }
 
-    return m_bindings[binding_id].deserialize(xml);
+        if(!m_bindings[binding_id].load(action))
-}   // deserializeAction
+        {
+            Log::error("Device manager",
+                       "Ignoring an ill-formed keyboard action in input config.");
+            error=true;
+        }
+    }   // for i in nodes
+    return !error;
+}   // load
 
+// ---------------------------------------------------------------------------
 
 //  KeyboardConfig & GamepadConfig classes really should be in a separate cpp
 //  file but they are so small that we'll just leave them here for now.
@@ -350,19 +367,13 @@ GamepadConfig::GamepadConfig   ( const std::string     &name,
 
 //------------------------------------------------------------------------------
 
-GamepadConfig::GamepadConfig(irr::io::IrrXMLReader* xml) : DeviceConfig( DEVICE_CONFIG_TYPE_GAMEPAD )
+GamepadConfig::GamepadConfig(const XMLNode *config) 
+             : DeviceConfig( DEVICE_CONFIG_TYPE_GAMEPAD )
 {
-    const char* name_string = xml->getAttributeValue("name");
+    if(!config->get("name", &m_name))
-    if(name_string == NULL)
         Log::error("DeviceConfig", "Unnamed joystick in config file.");
-    else
-        m_name = name_string;
 
-    const char* enabled_string = xml->getAttributeValue("enabled");
+    config->get("enabled", &m_enabled);
-    if (enabled_string != NULL)
-        m_enabled = (strcmp(enabled_string, "true") == 0);
-    else
-        m_enabled = true;
 
     m_plugged = 0;
     setDefaultBinds();

src/config/device_config.hpp

@@ -86,7 +86,7 @@ public:
     irr::core::stringw getMappingIdString (const PlayerAction action) const;
 
     void        serialize           (std::ofstream& stream);
-    bool        deserializeAction   (irr::io::IrrXMLReader* xml);
+    bool        load(const XMLNode *config);
 
     void        setBinding          (const PlayerAction     action,
                                      const Input::InputType type,
@@ -172,7 +172,7 @@ public:
 
     void        serialize           (std::ofstream& stream);
     void        setDefaultBinds     ();
-    GamepadConfig           (irr::io::IrrXMLReader* xml);
+    GamepadConfig           (const XMLNode *config);
     GamepadConfig           (const std::string     &name,
                              const int              axis_count=0,
                              const int              button_ount=0);

src/config/hardware_stats.cpp

@@ -257,6 +257,9 @@ const std::string& getOSVersion()
  */
 void reportHardwareStats()
 {
+    if(!UserConfigParams::m_hw_report_enable)
+        return;
+
     // Version of the hw report, which is stored in the DB. If new fields
     // are added, increase this version. Each STK installation will report
     // its configuration only once (per version number). So if the version

src/config/saved_grand_prix.cpp

@@ -68,6 +68,7 @@ SavedGrandPrix::SavedGrandPrix(unsigned int player_id,
                                RaceManager::Difficulty difficulty,
                                int player_karts,
                                int last_track,
+                               int reverse_type,
                                const std::vector<RaceManager::KartStatus> &kart_list)
               : m_savedgp_group("SavedGP",
                                 "Represents the saved state of a GP"),
@@ -75,7 +76,8 @@ SavedGrandPrix::SavedGrandPrix(unsigned int player_id,
                 m_gp_id(gp_id.c_str(), "gp_id", &m_savedgp_group),
                 m_difficulty((int)difficulty,"difficulty", &m_savedgp_group),
                 m_player_karts(player_karts,"player_karts", &m_savedgp_group),
-                m_next_track(last_track,"last_track", &m_savedgp_group)
+                m_next_track(last_track,"last_track", &m_savedgp_group),
+                m_reverse_type(reverse_type,"reverse_type", &m_savedgp_group)
 {
     for(unsigned int i =0; i < kart_list.size(); i++)
     {
@@ -94,18 +96,20 @@ SavedGrandPrix::SavedGrandPrix(unsigned int player_id,
 SavedGrandPrix::SavedGrandPrix(const XMLNode* node)
               : m_savedgp_group("SavedGP",
                                 "Represents the saved state of a GP"),
-                m_player_id(0, "player_id", &m_savedgp_group),
+                m_player_id   (0, "player_id",   &m_savedgp_group),
-                m_gp_id("-", "gp_id", &m_savedgp_group),
+                m_gp_id     ("-", "gp_id",       &m_savedgp_group),
-                m_difficulty(0,"difficulty", &m_savedgp_group),
+                m_difficulty  (0,"difficulty",   &m_savedgp_group),
                 m_player_karts(0,"player_karts", &m_savedgp_group),
-                m_next_track(0,"last_track", &m_savedgp_group)
+                m_next_track  (0,"last_track",   &m_savedgp_group),
+                m_reverse_type(0,"reverse_type", &m_savedgp_group)
 {
     //m_player_group.findYourDataInAChildOf(node);
-    m_player_id.findYourDataInAnAttributeOf(node);
+    m_player_id.   findYourDataInAnAttributeOf(node);
-    m_gp_id.findYourDataInAnAttributeOf(node);
+    m_gp_id.       findYourDataInAnAttributeOf(node);
-    m_difficulty.findYourDataInAnAttributeOf(node);
+    m_difficulty.  findYourDataInAnAttributeOf(node);
     m_player_karts.findYourDataInAnAttributeOf(node);
-    m_next_track.findYourDataInAnAttributeOf(node);
+    m_next_track.  findYourDataInAnAttributeOf(node);
+    m_reverse_type.findYourDataInAnAttributeOf(node);
 
     std::vector<XMLNode*> karts;
     node->getNodes("Kart", karts);
@@ -140,35 +144,41 @@ void SavedGrandPrix::setKarts(const std::vector<RaceManager::KartStatus> &kart_l
     }
 }   // setKarts
 
+/* compares two KartStatus-objects for std::sort in the next function */
+bool cmp__l(RaceManager::KartStatus first, RaceManager::KartStatus second)
+{
+    return (first.m_score > second.m_score);
+}
 //------------------------------------------------------------------------------
 void SavedGrandPrix::loadKarts(std::vector<RaceManager::KartStatus> & kart_list)
 {
-    //Fix aikarts
+
     int aikarts = 0;
     for(unsigned int i = 0; i < m_karts.size(); i++)
     {
         const KartProperties *kp = kart_properties_manager->getKart(m_karts[i].m_ident);
 
-        if(m_karts[i].m_local_player_id == -1)
+        if(m_karts[i].m_local_player_id == -1) // AI kart
         {
-            //AI kart found
             if(kp) kart_list[aikarts].m_ident = m_karts[i].m_ident;
-            kart_list[aikarts].m_score = m_karts[i].m_score;
+            kart_list[aikarts].m_score        = m_karts[i].m_score;
             kart_list[aikarts].m_overall_time = m_karts[i].m_overall_time;
             aikarts++;
         }
         else
         {
-            //Get correct player
+            // Get correct player
             for(unsigned int x = kart_list.size()-m_player_karts;
                 x < kart_list.size(); x++)
             {
                 if(kart_list[x].m_local_player_id == m_karts[i].m_local_player_id)
                 {
-                    kart_list[x].m_score = m_karts[i].m_score;
+                    kart_list[x].m_score        = m_karts[i].m_score;
                     kart_list[x].m_overall_time = m_karts[i].m_overall_time;
                 }   // if kart_list[x].m_local_player_id == m_karts[i].,_local
             }   // for x
         }   // if m_local_player_id == -1
     }   // for i
+
+    std::sort(kart_list.begin(), kart_list.end(), cmp__l);
 }   // loadKarts

src/config/saved_grand_prix.hpp

@@ -19,11 +19,13 @@
 #ifndef HEADER_SAVED_GRAND_PRIX_HPP
 #define HEADER_SAVED_GRAND_PRIX_HPP
 
-#include <string>
 #include "config/user_config.hpp"
 #include "race/race_manager.hpp"
 #include "utils/ptr_vector.hpp"
 
+#include <algorithm>
+#include <string>
+
 class RaceManager;
 
 // ============================================================================
@@ -74,6 +76,9 @@ protected:
     /** Index of the next to run track. */
     IntUserConfigParam          m_next_track;
 
+    /** GPReverseType of the GP as int */
+    IntUserConfigParam          m_reverse_type;
+
     PtrVector<SavedGPKart> m_karts;
 
 public:
@@ -86,6 +91,7 @@ public:
                    RaceManager::Difficulty difficulty,
                    int player_karts,
                    int last_track,
+                   int reverse_type,
                    const std::vector<RaceManager::KartStatus> &kart_list);
 
     /**
@@ -120,6 +126,10 @@ public:
     /** Returns the index of the last track finished when this GP was saved. */
     int getNextTrack() const { return m_next_track; }
 
+    // ------------------------------------------------------------------------
+    /** Returns the reverse Type. */
+    int getReverseType() const { return m_reverse_type; }
+
     // ------------------------------------------------------------------------
     /** Sets the index of the last track finished. */
     void setNextTrack(int next_track) { m_next_track = next_track; }
@@ -135,29 +145,22 @@ public:
 
     // ------------------------------------------------------------------------
     /** Finds the right SavedGrandPrix given the specified data, or
-     *  NULL if no matching GP was found.
+     *  NULL if no matching GP was found. */
-     */
     static SavedGrandPrix* getSavedGP(unsigned int player,
-                                const std::string &gpid,
+                                      const std::string &gpid,
-                                int difficulty, int total_karts,
+                                      const unsigned int number_of_players)
-                                int player_karts)
     {
         for (unsigned int n=0; n<UserConfigParams::m_saved_grand_prix_list.size(); n++)
         {
             SavedGrandPrix* gp = &UserConfigParams::m_saved_grand_prix_list[n];
-
+            if (gp->getGPID()        == gpid   &&
-            if ((gp->getGPID()       == gpid) &&
+                gp->getPlayerID()    == player &&
-                (gp->getPlayerID()    ==  player) &&
+                gp->getPlayerKarts() == (int)number_of_players)
-                (gp->getDifficulty()  == difficulty) &&
-                (gp->getTotalKarts()  == total_karts) &&
-                (gp->getPlayerKarts() == player_karts)){
                 return gp;
-            }   // if
+        }
-        }   // for n
         return NULL;
     }   // getSavedGP
     // ------------------------------------------------------------------------
-
 };   // class SavedGrandPrix
 
 #endif

src/config/user_config.hpp

@@ -704,6 +704,12 @@ namespace UserConfigParams
                                                      &m_hw_report_group,
                                                     "The server used for reporting statistics to."));
 
+    PARAM_PREFIX BoolUserConfigParam      m_hw_report_enable
+            PARAM_DEFAULT( BoolUserConfigParam(   true,
+                                                     "hw-report-enabled",
+                                                     &m_hw_report_group,
+                                                    "If HW reports are enabled."));
+
     // ---- User management
 
     PARAM_PREFIX BoolUserConfigParam        m_always_show_login_screen

src/graphics/2dutils.cpp

@@ -21,7 +21,7 @@ static void drawTexColoredQuad(const video::ITexture *texture, const video::SCol
     glUseProgram(UIShader::ColoredTextureRectShader::getInstance()->Program);
     glBindVertexArray(UIShader::ColoredTextureRectShader::getInstance()->vao);
 
-    UIShader::ColoredTextureRectShader::getInstance()->SetTextureUnits(createVector<GLuint>(static_cast<const irr::video::COpenGLTexture*>(texture)->getOpenGLTextureName()));
+    UIShader::ColoredTextureRectShader::getInstance()->SetTextureUnits(static_cast<const irr::video::COpenGLTexture*>(texture)->getOpenGLTextureName());
     UIShader::ColoredTextureRectShader::getInstance()->setUniforms(
         core::vector2df(center_pos_x, center_pos_y), core::vector2df(width, height),
         core::vector2df(tex_center_pos_x, tex_center_pos_y), core::vector2df(tex_width, tex_height));
@@ -41,7 +41,7 @@ float tex_width, float tex_height)
     glUseProgram(UIShader::TextureRectShader::getInstance()->Program);
     glBindVertexArray(SharedObject::UIVAO);
 
-    UIShader::TextureRectShader::getInstance()->SetTextureUnits(createVector<GLuint>(texture));
+    UIShader::TextureRectShader::getInstance()->SetTextureUnits(texture);
     UIShader::TextureRectShader::getInstance()->setUniforms(
         core::vector2df(center_pos_x, center_pos_y), core::vector2df(width, height),
         core::vector2df(tex_center_pos_x, tex_center_pos_y),
@@ -144,7 +144,7 @@ void draw2DImage(const video::ITexture* texture, const core::rect<s32>& destRect
     glUseProgram(UIShader::UniformColoredTextureRectShader::getInstance()->Program);
     glBindVertexArray(SharedObject::UIVAO);
 
-    UIShader::UniformColoredTextureRectShader::getInstance()->SetTextureUnits(createVector<GLuint>(static_cast<const irr::video::COpenGLTexture*>(texture)->getOpenGLTextureName()));
+    UIShader::UniformColoredTextureRectShader::getInstance()->SetTextureUnits(static_cast<const irr::video::COpenGLTexture*>(texture)->getOpenGLTextureName());
     UIShader::UniformColoredTextureRectShader::getInstance()->setUniforms(
         core::vector2df(center_pos_x, center_pos_y), core::vector2df(width, height), core::vector2df(tex_center_pos_x, tex_center_pos_y), core::vector2df(tex_width, tex_height), colors);
 
@@ -180,7 +180,7 @@ void draw2DImageFromRTT(GLuint texture, size_t texture_w, size_t texture_h,
     glUseProgram(UIShader::UniformColoredTextureRectShader::getInstance()->Program);
     glBindVertexArray(SharedObject::UIVAO);
 
-    UIShader::UniformColoredTextureRectShader::getInstance()->SetTextureUnits(createVector<GLuint>(texture));
+    UIShader::UniformColoredTextureRectShader::getInstance()->SetTextureUnits(texture);
     UIShader::UniformColoredTextureRectShader::getInstance()->setUniforms(
         core::vector2df(center_pos_x, center_pos_y), core::vector2df(width, height),
         core::vector2df(tex_center_pos_x, tex_center_pos_y), core::vector2df(tex_width, tex_height),
@@ -268,7 +268,7 @@ void draw2DVertexPrimitiveList(video::ITexture *tex, const void* vertices,
     UIShader::Primitive2DList::getInstance()->setUniforms();
     const video::SOverrideMaterial &m = irr_driver->getVideoDriver()->getOverrideMaterial();
     compressTexture(tex, false);
-    UIShader::Primitive2DList::getInstance()->SetTextureUnits({ getTextureGLuint(tex) });
+    UIShader::Primitive2DList::getInstance()->SetTextureUnits(getTextureGLuint(tex));
     glDrawElements(GL_TRIANGLE_FAN, primitiveCount, GL_UNSIGNED_SHORT, 0);
 
     glDeleteVertexArrays(1, &tmpvao);

src/graphics/gpuparticles.cpp

@@ -350,7 +350,7 @@ void ParticleSystemProxy::drawFlip()
     glBlendFunc(GL_ONE, GL_ONE);
     glUseProgram(ParticleShader::FlipParticleRender::getInstance()->Program);
 
-    ParticleShader::FlipParticleRender::getInstance()->SetTextureUnits(std::vector<GLuint>{ texture, irr_driver->getDepthStencilTexture() });
+    ParticleShader::FlipParticleRender::getInstance()->SetTextureUnits(texture, irr_driver->getDepthStencilTexture());
     ParticleShader::FlipParticleRender::getInstance()->setUniforms();
 
     glBindVertexArray(current_rendering_vao);
@@ -365,7 +365,7 @@ void ParticleSystemProxy::drawNotFlip()
         glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
     glUseProgram(ParticleShader::SimpleParticleRender::getInstance()->Program);
 
-    ParticleShader::SimpleParticleRender::getInstance()->SetTextureUnits(std::vector<GLuint>{ texture, irr_driver->getDepthStencilTexture() });
+    ParticleShader::SimpleParticleRender::getInstance()->SetTextureUnits(texture, irr_driver->getDepthStencilTexture());
     video::SColorf ColorFrom = video::SColorf(getColorFrom()[0], getColorFrom()[1], getColorFrom()[2]);
     video::SColorf ColorTo = video::SColorf(getColorTo()[0], getColorTo()[1], getColorTo()[2]);
 

src/graphics/irr_driver.cpp

@@ -578,7 +578,8 @@ void IrrDriver::initDevice()
             mb->getMaterial().setTexture(0, getUnicolorTexture(video::SColor(255, 255, 255, 255)));
             mb->getMaterial().setTexture(1, getUnicolorTexture(video::SColor(0, 0, 0, 0)));
         }
-        m_sun_interposer = new STKMeshSceneNode(sphere, m_scene_manager->getRootSceneNode(), NULL, -1);
+        m_sun_interposer = new STKMeshSceneNode(sphere, m_scene_manager->getRootSceneNode(), NULL, -1, "sun_interposer");
+
         m_sun_interposer->grab();
         m_sun_interposer->setParent(NULL);
         m_sun_interposer->setScale(core::vector3df(20));
@@ -1077,6 +1078,7 @@ scene::IParticleSystemSceneNode *IrrDriver::addParticleNode(bool default_emitter
  *  \param mesh The mesh to add.
  */
 scene::IMeshSceneNode *IrrDriver::addMesh(scene::IMesh *mesh,
+                                          const std::string& debug_name,
                                           scene::ISceneNode *parent)
 {
     if (!isGLSL())
@@ -1085,7 +1087,7 @@ scene::IMeshSceneNode *IrrDriver::addMesh(scene::IMesh *mesh,
     if (!parent)
       parent = m_scene_manager->getRootSceneNode();
 
-    scene::IMeshSceneNode* node = new STKMeshSceneNode(mesh, parent, m_scene_manager, -1);
+    scene::IMeshSceneNode* node = new STKMeshSceneNode(mesh, parent, m_scene_manager, -1, debug_name);
     node->drop();
 
     return node;
@@ -1261,21 +1263,25 @@ void IrrDriver::removeTexture(video::ITexture *t)
 /** Adds an animated mesh to the scene.
  *  \param mesh The animated mesh to add.
  */
-scene::IAnimatedMeshSceneNode *IrrDriver::addAnimatedMesh(scene::IAnimatedMesh *mesh, scene::ISceneNode* parent)
+scene::IAnimatedMeshSceneNode *IrrDriver::addAnimatedMesh(scene::IAnimatedMesh *mesh,
+    const std::string& debug_name, scene::ISceneNode* parent)
 {
     if (!isGLSL())
+    {
         return m_scene_manager->addAnimatedMeshSceneNode(mesh, parent, -1,
-                                                     core::vector3df(0,0,0),
+            core::vector3df(0, 0, 0),
-                                                     core::vector3df(0,0,0),
+            core::vector3df(0, 0, 0),
-                                                     core::vector3df(1,1,1),
+            core::vector3df(1, 1, 1),
-                                                     /*addIfMeshIsZero*/true);
+            /*addIfMeshIsZero*/true);
+    }
 
-      if (!parent)
+    if (!parent)
-         parent = m_scene_manager->getRootSceneNode();
+        parent = m_scene_manager->getRootSceneNode();
-      scene::IAnimatedMeshSceneNode* node =
+    scene::IAnimatedMeshSceneNode* node =
-         new STKAnimatedMesh(mesh, parent, m_scene_manager, -1, core::vector3df(0,0,0), core::vector3df(0,0,0), core::vector3df(1,1,1));
+        new STKAnimatedMesh(mesh, parent, m_scene_manager, -1, debug_name,
-      node->drop();
+        core::vector3df(0, 0, 0), core::vector3df(0, 0, 0), core::vector3df(1, 1, 1));
-      return node;
+    node->drop();
+    return node;
 }   // addAnimatedMesh
 
 // ----------------------------------------------------------------------------

src/graphics/irr_driver.hpp

@@ -453,6 +453,7 @@ public:
     scene::IMeshSceneNode*addSphere(float radius,
                  const video::SColor &color=video::SColor(128, 255, 255, 255));
     scene::IMeshSceneNode*addMesh(scene::IMesh *mesh,
+                                  const std::string& debug_name,
                                   scene::ISceneNode *parent=NULL);
     PerCameraNode        *addPerCameraNode(scene::ISceneNode* node,
                                            scene::ICameraSceneNode* cam,
@@ -473,7 +474,7 @@ public:
     void                  removeMeshFromCache(scene::IMesh *mesh);
     void                  removeTexture(video::ITexture *t);
     scene::IAnimatedMeshSceneNode
-                         *addAnimatedMesh(scene::IAnimatedMesh *mesh, scene::ISceneNode* parent=NULL);
+        *addAnimatedMesh(scene::IAnimatedMesh *mesh, const std::string& debug_name, scene::ISceneNode* parent = NULL);
     scene::ICameraSceneNode
                          *addCameraSceneNode();
     Camera               *addCamera(unsigned int index, AbstractKart *kart);

src/graphics/post_processing.cpp

@@ -217,7 +217,7 @@ static void DrawFullScreenEffect(Args...args)
 static
 void renderBloom(GLuint in)
 {
-    FullScreenShader::BloomShader::getInstance()->SetTextureUnits(createVector<GLuint>(in));
+    FullScreenShader::BloomShader::getInstance()->SetTextureUnits(in);
     DrawFullScreenEffect<FullScreenShader::BloomShader>();
 }
 
@@ -231,7 +231,7 @@ void PostProcessing::renderEnvMap(const float *bSHCoeff, const float *gSHCoeff,
     glUseProgram(FullScreenShader::EnvMapShader::getInstance()->Program);
     glBindVertexArray(SharedObject::FullScreenQuadVAO);
 
-    FullScreenShader::EnvMapShader::getInstance()->SetTextureUnits(createVector<GLuint>(irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), irr_driver->getDepthStencilTexture(), skybox));
+    FullScreenShader::EnvMapShader::getInstance()->SetTextureUnits(irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), irr_driver->getDepthStencilTexture(), skybox);
     core::matrix4 TVM = irr_driver->getViewMatrix().getTransposed();
     FullScreenShader::EnvMapShader::getInstance()->setUniforms(TVM, std::vector<float>(bSHCoeff, bSHCoeff + 9), std::vector<float>(gSHCoeff, gSHCoeff + 9), std::vector<float>(rSHCoeff, rSHCoeff + 9));
 
@@ -264,8 +264,8 @@ void PostProcessing::renderGI(const core::matrix4 &RHMatrix, const core::vector3
     core::matrix4 InvRHMatrix;
     RHMatrix.getInverse(InvRHMatrix);
     glDisable(GL_DEPTH_TEST);
-    FullScreenShader::GlobalIlluminationReconstructionShader::getInstance()->SetTextureUnits(createVector<GLuint>(
+    FullScreenShader::GlobalIlluminationReconstructionShader::getInstance()->SetTextureUnits(
-        irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), irr_driver->getDepthStencilTexture(), shr, shg, shb));
+        irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), irr_driver->getDepthStencilTexture(), shr, shg, shb);
     DrawFullScreenEffect<FullScreenShader::GlobalIlluminationReconstructionShader>(RHMatrix, InvRHMatrix, rh_extend);
 }
 
@@ -278,7 +278,7 @@ void PostProcessing::renderSunlight()
   glBlendFunc(GL_ONE, GL_ONE);
   glBlendEquation(GL_FUNC_ADD);
 
-  FullScreenShader::SunLightShader::getInstance()->SetTextureUnits(createVector<GLuint>(irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), irr_driver->getDepthStencilTexture()));
+  FullScreenShader::SunLightShader::getInstance()->SetTextureUnits(irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), irr_driver->getDepthStencilTexture());
   DrawFullScreenEffect<FullScreenShader::SunLightShader>(cb->getPosition(), video::SColorf(cb->getRed(), cb->getGreen(), cb->getBlue()));
 }
 
@@ -291,7 +291,7 @@ void PostProcessing::renderShadowedSunlight(const std::vector<core::matrix4> &su
     glBlendFunc(GL_ONE, GL_ONE);
     glBlendEquation(GL_FUNC_ADD);
 
-    FullScreenShader::ShadowedSunLightShader::getInstance()->SetTextureUnits(createVector<GLuint>( irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), irr_driver->getDepthStencilTexture(), depthtex ));
+    FullScreenShader::ShadowedSunLightShader::getInstance()->SetTextureUnits(irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), irr_driver->getDepthStencilTexture(), depthtex);
     DrawFullScreenEffect<FullScreenShader::ShadowedSunLightShader>(cb->getPosition(), video::SColorf(cb->getRed(), cb->getGreen(), cb->getBlue()));
 }
 
@@ -303,13 +303,13 @@ void PostProcessing::renderGaussian3Blur(FrameBuffer &in_fbo, FrameBuffer &auxil
     {
         auxiliary.Bind();
 
-        FullScreenShader::Gaussian3VBlurShader::getInstance()->SetTextureUnits(createVector<GLuint>(in_fbo.getRTT()[0]));
+        FullScreenShader::Gaussian3VBlurShader::getInstance()->SetTextureUnits(in_fbo.getRTT()[0]);
         DrawFullScreenEffect<FullScreenShader::Gaussian3VBlurShader>(core::vector2df(inv_width, inv_height));
     }
     {
         in_fbo.Bind();
 
-        FullScreenShader::Gaussian3HBlurShader::getInstance()->SetTextureUnits(createVector<GLuint>(auxiliary.getRTT()[0]));
+        FullScreenShader::Gaussian3HBlurShader::getInstance()->SetTextureUnits(auxiliary.getRTT()[0]);
         DrawFullScreenEffect<FullScreenShader::Gaussian3HBlurShader>(core::vector2df(inv_width, inv_height));
     }
 }
@@ -321,13 +321,13 @@ void PostProcessing::renderGaussian6Blur(FrameBuffer &in_fbo, FrameBuffer &auxil
     {
         auxiliary.Bind();
 
-        FullScreenShader::Gaussian6VBlurShader::getInstance()->SetTextureUnits(createVector<GLuint>(in_fbo.getRTT()[0]));
+        FullScreenShader::Gaussian6VBlurShader::getInstance()->SetTextureUnits(in_fbo.getRTT()[0]);
         DrawFullScreenEffect<FullScreenShader::Gaussian6VBlurShader>(core::vector2df(inv_width, inv_height));
     }
     {
         in_fbo.Bind();
 
-        FullScreenShader::Gaussian6HBlurShader::getInstance()->SetTextureUnits(createVector<GLuint>(auxiliary.getRTT()[0]));
+        FullScreenShader::Gaussian6HBlurShader::getInstance()->SetTextureUnits(auxiliary.getRTT()[0]);
         DrawFullScreenEffect<FullScreenShader::Gaussian6HBlurShader>(core::vector2df(inv_width, inv_height));
     }
 }
@@ -342,14 +342,14 @@ void PostProcessing::renderGaussian17TapBlur(FrameBuffer &in_fbo, FrameBuffer &a
         if (!irr_driver->hasARBComputeShaders())
         {
             auxiliary.Bind();
-            FullScreenShader::Gaussian17TapHShader::getInstance()->SetTextureUnits(createVector<GLuint>(in_fbo.getRTT()[0], irr_driver->getFBO(FBO_LINEAR_DEPTH).getRTT()[0]));
+            FullScreenShader::Gaussian17TapHShader::getInstance()->SetTextureUnits(in_fbo.getRTT()[0], irr_driver->getFBO(FBO_LINEAR_DEPTH).getRTT()[0]);
             DrawFullScreenEffect<FullScreenShader::Gaussian17TapHShader>(core::vector2df(inv_width, inv_height));
         }
         else
         {
             glUseProgram(FullScreenShader::ComputeGaussian17TapHShader::getInstance()->Program);
             glBindSampler(FullScreenShader::ComputeGaussian17TapHShader::getInstance()->TU_dest, 0);
-            FullScreenShader::ComputeGaussian17TapHShader::getInstance()->SetTextureUnits({ in_fbo.getRTT()[0], irr_driver->getFBO(FBO_LINEAR_DEPTH).getRTT()[0] });
+            FullScreenShader::ComputeGaussian17TapHShader::getInstance()->SetTextureUnits(in_fbo.getRTT()[0], irr_driver->getFBO(FBO_LINEAR_DEPTH).getRTT()[0]);
             glBindImageTexture(FullScreenShader::ComputeGaussian17TapHShader::getInstance()->TU_dest, auxiliary.getRTT()[0], 0, false, 0, GL_WRITE_ONLY, GL_R16F);
             FullScreenShader::ComputeGaussian17TapHShader::getInstance()->setUniforms(core::vector2df(inv_width, inv_height));
             glDispatchCompute((int)in_fbo.getWidth() / 8 + 1, (int)in_fbo.getHeight() / 8 + 1, 1);
@@ -362,14 +362,14 @@ void PostProcessing::renderGaussian17TapBlur(FrameBuffer &in_fbo, FrameBuffer &a
         {
             in_fbo.Bind();
 
-            FullScreenShader::Gaussian17TapVShader::getInstance()->SetTextureUnits(createVector<GLuint>(auxiliary.getRTT()[0], irr_driver->getFBO(FBO_LINEAR_DEPTH).getRTT()[0]));
+            FullScreenShader::Gaussian17TapVShader::getInstance()->SetTextureUnits(auxiliary.getRTT()[0], irr_driver->getFBO(FBO_LINEAR_DEPTH).getRTT()[0]);
             DrawFullScreenEffect<FullScreenShader::Gaussian17TapVShader>(core::vector2df(inv_width, inv_height));
         }
         else
         {
             glUseProgram(FullScreenShader::ComputeGaussian17TapVShader::getInstance()->Program);
             glBindSampler(FullScreenShader::ComputeGaussian17TapVShader::getInstance()->TU_dest, 0);
-            FullScreenShader::ComputeGaussian17TapVShader::getInstance()->SetTextureUnits({ auxiliary.getRTT()[0], irr_driver->getFBO(FBO_LINEAR_DEPTH).getRTT()[0] });
+            FullScreenShader::ComputeGaussian17TapVShader::getInstance()->SetTextureUnits(auxiliary.getRTT()[0], irr_driver->getFBO(FBO_LINEAR_DEPTH).getRTT()[0]);
             glBindImageTexture(FullScreenShader::ComputeGaussian17TapVShader::getInstance()->TU_dest, in_fbo.getRTT()[0], 0, false, 0, GL_WRITE_ONLY, GL_R16F);
             FullScreenShader::ComputeGaussian17TapVShader::getInstance()->setUniforms(core::vector2df(inv_width, inv_height));
             glDispatchCompute((int)in_fbo.getWidth() / 8 + 1, (int)in_fbo.getHeight() / 8 + 1, 1);
@@ -384,7 +384,7 @@ void PostProcessing::renderPassThrough(GLuint tex)
     glUseProgram(FullScreenShader::PassThroughShader::getInstance()->Program);
     glBindVertexArray(FullScreenShader::PassThroughShader::getInstance()->vao);
 
-    FullScreenShader::PassThroughShader::getInstance()->SetTextureUnits(createVector<GLuint>(tex));
+    FullScreenShader::PassThroughShader::getInstance()->SetTextureUnits(tex);
     FullScreenShader::PassThroughShader::getInstance()->setUniforms();
 
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
@@ -409,7 +409,7 @@ void PostProcessing::renderGlow(unsigned tex)
     glUseProgram(FullScreenShader::GlowShader::getInstance()->Program);
     glBindVertexArray(FullScreenShader::GlowShader::getInstance()->vao);
 
-    FullScreenShader::GlowShader::getInstance()->SetTextureUnits(createVector<GLuint>(tex));
+    FullScreenShader::GlowShader::getInstance()->SetTextureUnits(tex);
     FullScreenShader::GlowShader::getInstance()->setUniforms();
 
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
@@ -422,11 +422,11 @@ void PostProcessing::renderSSAO()
 
     // Generate linear depth buffer
     irr_driver->getFBO(FBO_LINEAR_DEPTH).Bind();
-    FullScreenShader::LinearizeDepthShader::getInstance()->SetTextureUnits(createVector<GLuint>(irr_driver->getDepthStencilTexture()));
+    FullScreenShader::LinearizeDepthShader::getInstance()->SetTextureUnits(irr_driver->getDepthStencilTexture());
     DrawFullScreenEffect<FullScreenShader::LinearizeDepthShader>(irr_driver->getSceneManager()->getActiveCamera()->getNearValue(), irr_driver->getSceneManager()->getActiveCamera()->getFarValue());
     irr_driver->getFBO(FBO_SSAO).Bind();
 
-    FullScreenShader::SSAOShader::getInstance()->SetTextureUnits(createVector<GLuint>(irr_driver->getRenderTargetTexture(RTT_LINEAR_DEPTH)));
+    FullScreenShader::SSAOShader::getInstance()->SetTextureUnits(irr_driver->getRenderTargetTexture(RTT_LINEAR_DEPTH));
     glGenerateMipmap(GL_TEXTURE_2D);
 
     DrawFullScreenEffect<FullScreenShader::SSAOShader>(irr_driver->getSSAORadius(), irr_driver->getSSAOK(), irr_driver->getSSAOSigma());
@@ -454,7 +454,7 @@ void PostProcessing::renderFog()
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
 
-    FullScreenShader::FogShader::getInstance()->SetTextureUnits(createVector<GLuint>(irr_driver->getDepthStencilTexture()));
+    FullScreenShader::FogShader::getInstance()->SetTextureUnits(irr_driver->getDepthStencilTexture());
     DrawFullScreenEffect<FullScreenShader::FogShader>(fogmax, startH, endH, start, end, col);
 
     glEnable(GL_DEPTH_TEST);
@@ -487,7 +487,7 @@ void PostProcessing::renderMotionBlur(unsigned cam, FrameBuffer &in_fbo, FrameBu
     out_fbo.Bind();
     glClear(GL_COLOR_BUFFER_BIT);
 
-    FullScreenShader::MotionBlurShader::getInstance()->SetTextureUnits(createVector<GLuint>(in_fbo.getRTT()[0], irr_driver->getDepthStencilTexture()));
+    FullScreenShader::MotionBlurShader::getInstance()->SetTextureUnits(in_fbo.getRTT()[0], irr_driver->getDepthStencilTexture());
     DrawFullScreenEffect<FullScreenShader::MotionBlurShader>(
                                   // Todo : use a previousPVMatrix per cam, not global
                                   irr_driver->getPreviousPVMatrix(),
@@ -500,7 +500,7 @@ static void renderGodFade(GLuint tex, const SColor &col)
 {
     glUseProgram(FullScreenShader::GodFadeShader::getInstance()->Program);
     glBindVertexArray(FullScreenShader::GodFadeShader::getInstance()->vao);
-    FullScreenShader::GodFadeShader::getInstance()->SetTextureUnits(createVector<GLuint>(tex));
+    FullScreenShader::GodFadeShader::getInstance()->SetTextureUnits(tex);
     FullScreenShader::GodFadeShader::getInstance()->setUniforms(col);
 
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
@@ -510,7 +510,7 @@ static void renderGodRay(GLuint tex, const core::vector2df &sunpos)
 {
     glUseProgram(FullScreenShader::GodRayShader::getInstance()->Program);
     glBindVertexArray(FullScreenShader::GodRayShader::getInstance()->vao);
-    FullScreenShader::GodRayShader::getInstance()->SetTextureUnits(createVector<GLuint>(tex));
+    FullScreenShader::GodRayShader::getInstance()->SetTextureUnits(tex);
     FullScreenShader::GodRayShader::getInstance()->setUniforms(sunpos);
 
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
@@ -519,14 +519,14 @@ static void renderGodRay(GLuint tex, const core::vector2df &sunpos)
 static void toneMap(FrameBuffer &fbo, GLuint rtt)
 {
     fbo.Bind();
-    FullScreenShader::ToneMapShader::getInstance()->SetTextureUnits(createVector<GLuint>(rtt));
+    FullScreenShader::ToneMapShader::getInstance()->SetTextureUnits(rtt);
     DrawFullScreenEffect<FullScreenShader::ToneMapShader>();
 }
 
 static void renderDoF(FrameBuffer &fbo, GLuint rtt)
 {
     fbo.Bind();
-    FullScreenShader::DepthOfFieldShader::getInstance()->SetTextureUnits(createVector<GLuint>(rtt, irr_driver->getDepthStencilTexture()));
+    FullScreenShader::DepthOfFieldShader::getInstance()->SetTextureUnits(rtt, irr_driver->getDepthStencilTexture());
     DrawFullScreenEffect<FullScreenShader::DepthOfFieldShader>();
 }
 
@@ -543,7 +543,7 @@ void PostProcessing::applyMLAA()
 
     // Pass 1: color edge detection
     glUseProgram(FullScreenShader::MLAAColorEdgeDetectionSHader::getInstance()->Program);
-    FullScreenShader::MLAAColorEdgeDetectionSHader::getInstance()->SetTextureUnits(createVector<GLuint>(irr_driver->getRenderTargetTexture(RTT_MLAA_COLORS)));
+    FullScreenShader::MLAAColorEdgeDetectionSHader::getInstance()->SetTextureUnits(irr_driver->getRenderTargetTexture(RTT_MLAA_COLORS));
     FullScreenShader::MLAAColorEdgeDetectionSHader::getInstance()->setUniforms(PIXEL_SIZE);
 
     glBindVertexArray(FullScreenShader::MLAAColorEdgeDetectionSHader::getInstance()->vao);
@@ -557,7 +557,7 @@ void PostProcessing::applyMLAA()
     glClear(GL_COLOR_BUFFER_BIT);
 
     glUseProgram(FullScreenShader::MLAABlendWeightSHader::getInstance()->Program);
-    FullScreenShader::MLAABlendWeightSHader::getInstance()->SetTextureUnits(createVector<GLuint>(irr_driver->getRenderTargetTexture(RTT_MLAA_TMP), getTextureGLuint(m_areamap)));
+    FullScreenShader::MLAABlendWeightSHader::getInstance()->SetTextureUnits(irr_driver->getRenderTargetTexture(RTT_MLAA_TMP), getTextureGLuint(m_areamap));
     FullScreenShader::MLAABlendWeightSHader::getInstance()->setUniforms(PIXEL_SIZE);
 
     glBindVertexArray(FullScreenShader::MLAABlendWeightSHader::getInstance()->vao);
@@ -570,7 +570,7 @@ void PostProcessing::applyMLAA()
     irr_driver->getFBO(FBO_MLAA_COLORS).Bind();
 
     glUseProgram(FullScreenShader::MLAAGatherSHader::getInstance()->Program);
-    FullScreenShader::MLAAGatherSHader::getInstance()->SetTextureUnits(createVector<GLuint>(irr_driver->getRenderTargetTexture(RTT_MLAA_BLEND), irr_driver->getRenderTargetTexture(RTT_MLAA_TMP)));
+    FullScreenShader::MLAAGatherSHader::getInstance()->SetTextureUnits(irr_driver->getRenderTargetTexture(RTT_MLAA_BLEND), irr_driver->getRenderTargetTexture(RTT_MLAA_TMP));
     FullScreenShader::MLAAGatherSHader::getInstance()->setUniforms(PIXEL_SIZE);
 
     glBindVertexArray(FullScreenShader::MLAAGatherSHader::getInstance()->vao);
@@ -704,8 +704,8 @@ FrameBuffer *PostProcessing::render(scene::ICameraSceneNode * const camnode, boo
             glEnable(GL_BLEND);
             glBlendFunc(GL_ONE, GL_ONE);
             glBlendEquation(GL_FUNC_ADD);
-            FullScreenShader::BloomBlendShader::getInstance()->SetTextureUnits(createVector<GLuint>(
+            FullScreenShader::BloomBlendShader::getInstance()->SetTextureUnits(
-                irr_driver->getRenderTargetTexture(RTT_BLOOM_128), irr_driver->getRenderTargetTexture(RTT_BLOOM_256), irr_driver->getRenderTargetTexture(RTT_BLOOM_512) ));
+                irr_driver->getRenderTargetTexture(RTT_BLOOM_128), irr_driver->getRenderTargetTexture(RTT_BLOOM_256), irr_driver->getRenderTargetTexture(RTT_BLOOM_512));
             DrawFullScreenEffect<FullScreenShader::BloomBlendShader>();
 
             glDisable(GL_BLEND);

src/graphics/referee.cpp

@@ -139,7 +139,7 @@ Referee::Referee()
     // mesh. ATM it doesn't make any difference, but if we ever should
     // decide to use more than one referee model at startup we only
     // have to change the textures once, and all models will be in synch.
-    m_scene_node = irr_driver->addAnimatedMesh(NULL);
+    m_scene_node = irr_driver->addAnimatedMesh(NULL, "referee");
     m_scene_node->setReadOnlyMaterials(true);
     m_scene_node->setMesh(m_st_referee_mesh);
     m_scene_node->grab();
@@ -175,7 +175,7 @@ Referee::Referee(const AbstractKart &kart)
     // mesh. ATM it doesn't make any difference, but if we ever should
     // decide to use more than one referee model at startup we only
     // have to change the textures once, and all models will be in synch.
-    m_scene_node = irr_driver->addAnimatedMesh(NULL);
+    m_scene_node = irr_driver->addAnimatedMesh(NULL, "referee");
     m_scene_node->setReadOnlyMaterials(true);
     m_scene_node->setMesh(m_st_referee_mesh);
     m_scene_node->grab();

src/graphics/render_geometry.cpp

@@ -63,140 +63,202 @@ struct DefaultMaterial
 {
     typedef MeshShader::InstancedObjectPass1Shader InstancedFirstPassShader;
     typedef MeshShader::InstancedObjectPass2Shader InstancedSecondPassShader;
+    typedef MeshShader::InstancedShadowShader InstancedShadowPassShader;
+    typedef MeshShader::InstancedRSMShader InstancedRSMShader;
     typedef ListInstancedMatDefault InstancedList;
     typedef MeshShader::ObjectPass1Shader FirstPassShader;
     typedef MeshShader::ObjectPass2Shader SecondPassShader;
+    typedef MeshShader::ShadowShader ShadowPassShader;
+    typedef MeshShader::RSMShader RSMShader;
     typedef ListMatDefault List;
     static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
     static const enum Material::ShaderType MaterialType = Material::SHADERTYPE_SOLID;
     static const enum InstanceType Instance = InstanceTypeDualTex;
-    static const std::vector<size_t> FirstPassTextures;
+    static const STK::Tuple<size_t> FirstPassTextures;
-    static const std::vector<size_t> SecondPassTextures;
+    static const STK::Tuple<size_t, size_t> SecondPassTextures;
+    static const STK::Tuple<> ShadowTextures;
+    static const STK::Tuple<size_t> RSMTextures;
 };
 
-const std::vector<size_t> DefaultMaterial::FirstPassTextures = { 1 };
+const STK::Tuple<size_t> DefaultMaterial::FirstPassTextures = STK::Tuple<size_t>(1);
-const std::vector<size_t> DefaultMaterial::SecondPassTextures = { 0, 1 };
+const STK::Tuple<size_t, size_t> DefaultMaterial::SecondPassTextures = STK::Tuple<size_t, size_t>(0, 1);
+const STK::Tuple<> DefaultMaterial::ShadowTextures;
+const STK::Tuple<size_t> DefaultMaterial::RSMTextures = STK::Tuple<size_t>(0);
 
 struct AlphaRef
 {
     typedef MeshShader::InstancedObjectRefPass1Shader InstancedFirstPassShader;
     typedef MeshShader::InstancedObjectRefPass2Shader InstancedSecondPassShader;
+    typedef MeshShader::InstancedRefShadowShader InstancedShadowPassShader;
+    typedef MeshShader::InstancedRSMShader InstancedRSMShader;
     typedef ListInstancedMatAlphaRef InstancedList;
     typedef MeshShader::ObjectRefPass1Shader FirstPassShader;
     typedef MeshShader::ObjectRefPass2Shader SecondPassShader;
+    typedef MeshShader::RefShadowShader ShadowPassShader;
+    typedef MeshShader::RSMShader RSMShader;
     typedef ListMatAlphaRef List;
     static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
     static const enum Material::ShaderType MaterialType = Material::SHADERTYPE_ALPHA_TEST;
     static const enum InstanceType Instance = InstanceTypeDualTex;
-    static const std::vector<size_t> FirstPassTextures;
+    static const STK::Tuple<size_t, size_t> FirstPassTextures;
-    static const std::vector<size_t> SecondPassTextures;
+    static const STK::Tuple<size_t, size_t> SecondPassTextures;
+    static const STK::Tuple<size_t> ShadowTextures;
+    static const STK::Tuple<size_t> RSMTextures;
 };
 
-const std::vector<size_t> AlphaRef::FirstPassTextures = { 0, 1 };
+const STK::Tuple<size_t, size_t> AlphaRef::FirstPassTextures = STK::Tuple<size_t, size_t>(0, 1);
-const std::vector<size_t> AlphaRef::SecondPassTextures = { 0, 1 };
+const STK::Tuple<size_t, size_t> AlphaRef::SecondPassTextures = STK::Tuple<size_t, size_t>(0, 1);
+const STK::Tuple<size_t> AlphaRef::ShadowTextures = STK::Tuple<size_t>(0);
+const STK::Tuple<size_t> AlphaRef::RSMTextures = STK::Tuple<size_t>(0);
 
 struct SphereMap
 {
     typedef MeshShader::InstancedObjectPass1Shader InstancedFirstPassShader;
     typedef MeshShader::InstancedSphereMapShader InstancedSecondPassShader;
+    typedef MeshShader::InstancedShadowShader InstancedShadowPassShader;
+    typedef MeshShader::InstancedRSMShader InstancedRSMShader;
     typedef ListInstancedMatSphereMap InstancedList;
     typedef MeshShader::ObjectPass1Shader FirstPassShader;
     typedef MeshShader::SphereMapShader SecondPassShader;
+    typedef MeshShader::ShadowShader ShadowPassShader;
+    typedef MeshShader::RSMShader RSMShader;
     typedef ListMatSphereMap List;
     static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
     static const enum Material::ShaderType MaterialType = Material::SHADERTYPE_SPHERE_MAP;
     static const enum InstanceType Instance = InstanceTypeDualTex;
-    static const std::vector<size_t> FirstPassTextures;
+    static const STK::Tuple<size_t> FirstPassTextures;
-    static const std::vector<size_t> SecondPassTextures;
+    static const STK::Tuple<size_t> SecondPassTextures;
+    static const STK::Tuple<> ShadowTextures;
+    static const STK::Tuple<size_t> RSMTextures;
 };
 
-const std::vector<size_t> SphereMap::FirstPassTextures = { 1 };
+const STK::Tuple<size_t> SphereMap::FirstPassTextures = STK::Tuple<size_t>(1);
-const std::vector<size_t> SphereMap::SecondPassTextures = { 0 };
+const STK::Tuple<size_t> SphereMap::SecondPassTextures = STK::Tuple<size_t>(0);
+const STK::Tuple<> SphereMap::ShadowTextures;
+const STK::Tuple<size_t> SphereMap::RSMTextures = STK::Tuple<size_t>(0);
 
 struct UnlitMat
 {
     typedef MeshShader::InstancedObjectRefPass1Shader InstancedFirstPassShader;
     typedef MeshShader::InstancedObjectUnlitShader InstancedSecondPassShader;
+    typedef MeshShader::InstancedRefShadowShader InstancedShadowPassShader;
+    typedef MeshShader::InstancedRSMShader InstancedRSMShader;
     typedef ListInstancedMatUnlit InstancedList;
     typedef MeshShader::ObjectRefPass1Shader FirstPassShader;
     typedef MeshShader::ObjectUnlitShader SecondPassShader;
+    typedef MeshShader::RefShadowShader ShadowPassShader;
+    typedef MeshShader::RSMShader RSMShader;
     typedef ListMatUnlit List;
     static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
     static const enum Material::ShaderType MaterialType = Material::SHADERTYPE_SOLID_UNLIT;
     static const enum InstanceType Instance = InstanceTypeDualTex;
-    static const std::vector<size_t> FirstPassTextures;
+    static const STK::Tuple<size_t, size_t> FirstPassTextures;
-    static const std::vector<size_t> SecondPassTextures;
+    static const STK::Tuple<size_t> SecondPassTextures;
+    static const STK::Tuple<size_t> ShadowTextures;
+    static const STK::Tuple<size_t> RSMTextures;
 };
 
-const std::vector<size_t> UnlitMat::FirstPassTextures = { 0, 1 };
+const STK::Tuple<size_t, size_t> UnlitMat::FirstPassTextures = STK::Tuple<size_t, size_t>(0, 1);
-const std::vector<size_t> UnlitMat::SecondPassTextures = { 0 };
+const STK::Tuple<size_t> UnlitMat::SecondPassTextures = STK::Tuple<size_t>(0);
+const STK::Tuple<size_t> UnlitMat::ShadowTextures = STK::Tuple<size_t>(0);
+const STK::Tuple<size_t> UnlitMat::RSMTextures = STK::Tuple<size_t>(0);
 
 struct GrassMat
 {
     typedef MeshShader::InstancedGrassPass1Shader InstancedFirstPassShader;
     typedef MeshShader::InstancedGrassPass2Shader InstancedSecondPassShader;
+    typedef MeshShader::InstancedGrassShadowShader InstancedShadowPassShader;
+    typedef MeshShader::InstancedRSMShader InstancedRSMShader;
     typedef ListInstancedMatGrass InstancedList;
     typedef MeshShader::GrassPass1Shader FirstPassShader;
     typedef MeshShader::GrassPass2Shader SecondPassShader;
+    typedef MeshShader::GrassShadowShader ShadowPassShader;
+    typedef MeshShader::RSMShader RSMShader;
     typedef ListMatGrass List;
     static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
     static const enum Material::ShaderType MaterialType = Material::SHADERTYPE_VEGETATION;
     static const enum InstanceType Instance = InstanceTypeDualTex;
-    static const std::vector<size_t> FirstPassTextures;
+    static const STK::Tuple<size_t, size_t> FirstPassTextures;
-    static const std::vector<size_t> SecondPassTextures;
+    static const STK::Tuple<size_t, size_t> SecondPassTextures;
+    static const STK::Tuple<size_t> ShadowTextures;
+    static const STK::Tuple<size_t> RSMTextures;
 };
 
-const std::vector<size_t> GrassMat::FirstPassTextures = { 0, 1 };
+const STK::Tuple<size_t, size_t> GrassMat::FirstPassTextures = STK::Tuple<size_t, size_t>(0, 1);
-const std::vector<size_t> GrassMat::SecondPassTextures = { 0, 1 };
+const STK::Tuple<size_t, size_t> GrassMat::SecondPassTextures = STK::Tuple<size_t, size_t>(0, 1);
+const STK::Tuple<size_t> GrassMat::ShadowTextures = STK::Tuple<size_t>(0);
+const STK::Tuple<size_t> GrassMat::RSMTextures = STK::Tuple<size_t>(0);
 
 struct NormalMat
 {
     typedef MeshShader::InstancedNormalMapShader InstancedFirstPassShader;
     typedef MeshShader::InstancedObjectPass2Shader InstancedSecondPassShader;
+    typedef MeshShader::InstancedShadowShader InstancedShadowPassShader;
+    typedef MeshShader::InstancedRSMShader InstancedRSMShader;
     typedef ListInstancedMatNormalMap InstancedList;
     typedef MeshShader::NormalMapShader FirstPassShader;
     typedef MeshShader::ObjectPass2Shader SecondPassShader;
+    typedef MeshShader::ShadowShader ShadowPassShader;
+    typedef MeshShader::RSMShader RSMShader;
     typedef ListMatNormalMap List;
     static const enum video::E_VERTEX_TYPE VertexType = video::EVT_TANGENTS;
     static const enum Material::ShaderType MaterialType = Material::SHADERTYPE_NORMAL_MAP;
     static const enum InstanceType Instance = InstanceTypeThreeTex;
-    static const std::vector<size_t> FirstPassTextures;
+    static const STK::Tuple<size_t, size_t> FirstPassTextures;
-    static const std::vector<size_t> SecondPassTextures;
+    static const STK::Tuple<size_t, size_t> SecondPassTextures;
+    static const STK::Tuple<> ShadowTextures;
+    static const STK::Tuple<size_t> RSMTextures;
 };
 
-const std::vector<size_t> NormalMat::FirstPassTextures = { 2, 1 };
+const STK::Tuple<size_t, size_t> NormalMat::FirstPassTextures = STK::Tuple<size_t, size_t>(2, 1);
-const std::vector<size_t> NormalMat::SecondPassTextures = { 0, 1 };
+const STK::Tuple<size_t, size_t> NormalMat::SecondPassTextures = STK::Tuple<size_t, size_t>(0, 1);
+const STK::Tuple<> NormalMat::ShadowTextures;
+const STK::Tuple<size_t> NormalMat::RSMTextures = STK::Tuple<size_t>(0);
 
 struct DetailMat
 {
     typedef MeshShader::InstancedObjectPass1Shader InstancedFirstPassShader;
     typedef MeshShader::InstancedDetailledObjectPass2Shader InstancedSecondPassShader;
+    typedef MeshShader::InstancedShadowShader InstancedShadowPassShader;
+    typedef MeshShader::InstancedRSMShader InstancedRSMShader;
     typedef ListInstancedMatDetails InstancedList;
     typedef MeshShader::ObjectPass1Shader FirstPassShader;
     typedef MeshShader::DetailledObjectPass2Shader SecondPassShader;
+    typedef MeshShader::ShadowShader ShadowPassShader;
+    typedef MeshShader::RSMShader RSMShader;
     typedef ListMatDetails List;
     static const enum video::E_VERTEX_TYPE VertexType = video::EVT_2TCOORDS;
     static const enum Material::ShaderType MaterialType = Material::SHADERTYPE_DETAIL_MAP;
     static const enum InstanceType Instance = InstanceTypeThreeTex;
-    static const std::vector<size_t> FirstPassTextures;
+    static const STK::Tuple<size_t> FirstPassTextures;
-    static const std::vector<size_t> SecondPassTextures;
+    static const STK::Tuple<size_t, size_t, size_t> SecondPassTextures;
+    static const STK::Tuple<> ShadowTextures;
+    static const STK::Tuple<size_t> RSMTextures;
 };
 
-const std::vector<size_t> DetailMat::FirstPassTextures = { 1 };
+const STK::Tuple<size_t> DetailMat::FirstPassTextures = STK::Tuple<size_t>(1);
-const std::vector<size_t> DetailMat::SecondPassTextures = { 0, 2, 1 };
+const STK::Tuple<size_t, size_t, size_t> DetailMat::SecondPassTextures = STK::Tuple<size_t, size_t, size_t>(0, 2, 1);
+const STK::Tuple<> DetailMat::ShadowTextures;
+const STK::Tuple<size_t> DetailMat::RSMTextures = STK::Tuple<size_t>(0);
 
 struct SplattingMat
 {
     typedef MeshShader::ObjectPass1Shader FirstPassShader;
     typedef MeshShader::SplattingShader SecondPassShader;
+    typedef MeshShader::ShadowShader ShadowPassShader;
+    typedef MeshShader::SplattingRSMShader RSMShader;
     typedef ListMatSplatting List;
     static const enum video::E_VERTEX_TYPE VertexType = video::EVT_2TCOORDS;
-    static const std::vector<size_t> FirstPassTextures;
+    static const STK::Tuple<size_t> FirstPassTextures;
-    static const std::vector<size_t> SecondPassTextures;
+    static const STK::Tuple<size_t, size_t, size_t, size_t, size_t> SecondPassTextures;
+    static const STK::Tuple<> ShadowTextures;
+    static const STK::Tuple<size_t, size_t, size_t, size_t, size_t> RSMTextures;
 };
 
-const std::vector<size_t> SplattingMat::FirstPassTextures = { 6 };
+const STK::Tuple<size_t> SplattingMat::FirstPassTextures = STK::Tuple<size_t>(6);
-const std::vector<size_t> SplattingMat::SecondPassTextures = { 1, 2, 3, 4, 5 };
+const STK::Tuple<size_t, size_t, size_t, size_t, size_t> SplattingMat::SecondPassTextures = STK::Tuple<size_t, size_t, size_t, size_t, size_t>(1, 2, 3, 4, 5);
+const STK::Tuple<> SplattingMat::ShadowTextures;
+const STK::Tuple<size_t, size_t, size_t, size_t, size_t> SplattingMat::RSMTextures = STK::Tuple<size_t, size_t, size_t, size_t, size_t>(1, 2, 3, 4, 5);
 
 namespace RenderGeometry
 {
@@ -280,11 +342,72 @@ struct custom_unroll_args<N, List...>
     }
 };
 
+template<typename T, int N>
+struct TexExpander_impl
+{
+    template<typename...TupleArgs, typename... Args>
+    static void ExpandTex(GLMesh &mesh, const STK::Tuple<TupleArgs...> &TexSwizzle, Args... args)
+    {
+        size_t idx = STK::tuple_get<sizeof...(TupleArgs) - N>(TexSwizzle);
+        TexExpander_impl<T, N - 1>::template ExpandTex(mesh, TexSwizzle, args..., getTextureGLuint(mesh.textures[idx]));
+    }
+};
+
+template<typename T>
+struct TexExpander_impl<T, 0>
+{
+    template<typename...TupleArgs, typename... Args>
+    static void ExpandTex(GLMesh &mesh, const STK::Tuple<TupleArgs...> &TexSwizzle, Args... args)
+    {
+        T::getInstance()->SetTextureUnits(args...);
+    }
+};
+
+template<typename T>
+struct TexExpander
+{
+    template<typename...TupleArgs, typename... Args>
+    static void ExpandTex(GLMesh &mesh, const STK::Tuple<TupleArgs...> &TexSwizzle, Args... args)
+    {
+        TexExpander_impl<T, sizeof...(TupleArgs)>::ExpandTex(mesh, TexSwizzle, args...);
+    }
+};
+
+
+template<typename T, int N>
+struct HandleExpander_impl
+{
+    template<typename...TupleArgs, typename... Args>
+    static void Expand(uint64_t *TextureHandles, const STK::Tuple<TupleArgs...> &TexSwizzle, Args... args)
+    {
+        size_t idx = STK::tuple_get<sizeof...(TupleArgs)-N>(TexSwizzle);
+        HandleExpander_impl<T, N - 1>::template Expand(TextureHandles, TexSwizzle, args..., TextureHandles[idx]);
+    }
+};
+
+template<typename T>
+struct HandleExpander_impl<T, 0>
+{
+    template<typename...TupleArgs, typename... Args>
+    static void Expand(uint64_t *TextureHandles, const STK::Tuple<TupleArgs...> &TexSwizzle, Args... args)
+    {
+        T::getInstance()->SetTextureHandles(args...);
+    }
+};
+
+template<typename T>
+struct HandleExpander
+{
+    template<typename...TupleArgs, typename... Args>
+    static void Expand(uint64_t *TextureHandles, const STK::Tuple<TupleArgs...> &TexSwizzle, Args... args)
+    {
+        HandleExpander_impl<T, sizeof...(TupleArgs)>::Expand(TextureHandles, TexSwizzle, args...);
+    }
+};
 
 template<typename T, int ...List>
 void renderMeshes1stPass()
 {
-    const std::vector<size_t> &TexUnits = T::FirstPassTextures;
     auto &meshes = T::List::getInstance()->SolidPass;
     glUseProgram(T::FirstPassShader::getInstance()->Program);
     if (irr_driver->hasARB_base_instance())
@@ -296,13 +419,6 @@ void renderMeshes1stPass()
         GLMesh &mesh = *(STK::tuple_get<0>(meshes.at(i)));
         if (!irr_driver->hasARB_base_instance())
             glBindVertexArray(mesh.vao);
-        for (unsigned j = 0; j < TexUnits.size(); j++)
-        {
-            if (UserConfigParams::m_azdo)
-                Handles.push_back(mesh.TextureHandles[TexUnits[j]]);
-            else
-                Textures.push_back(getTextureGLuint(mesh.textures[TexUnits[j]]));
-        }
         if (mesh.VAOType != T::VertexType)
         {
 #ifdef DEBUG
@@ -312,9 +428,9 @@ void renderMeshes1stPass()
         }
 
         if (UserConfigParams::m_azdo)
-            T::FirstPassShader::getInstance()->SetTextureHandles(Handles);
+            HandleExpander<typename T::FirstPassShader>::template Expand(mesh.TextureHandles, T::FirstPassTextures);
         else
-            T::FirstPassShader::getInstance()->SetTextureUnits(Textures);
+            TexExpander<typename T::FirstPassShader>::template ExpandTex(mesh, T::FirstPassTextures);
         custom_unroll_args<List...>::template exec(T::FirstPassShader::getInstance(), meshes.at(i));
     }
 }
@@ -322,7 +438,6 @@ void renderMeshes1stPass()
 template<typename T, typename...Args>
 void renderInstancedMeshes1stPass(Args...args)
 {
-    const std::vector<size_t> &TexUnits = T::FirstPassTextures;
     std::vector<GLMesh *> &meshes = T::InstancedList::getInstance()->SolidPass;
     glUseProgram(T::InstancedFirstPassShader::getInstance()->Program);
     glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, T::Instance));
@@ -335,9 +450,7 @@ void renderInstancedMeshes1stPass(Args...args)
             Log::error("RenderGeometry", "Wrong instanced vertex format (hint : %s)", 
                         mesh->textures[0]->getName().getPath().c_str());
 #endif
-        for (unsigned j = 0; j < TexUnits.size(); j++)
+        TexExpander<typename T::InstancedFirstPassShader>::template ExpandTex(*mesh, T::FirstPassTextures);
-            Textures.push_back(getTextureGLuint(mesh->textures[TexUnits[j]]));
-        T::InstancedFirstPassShader::getInstance()->SetTextureUnits(Textures);
 
         T::InstancedFirstPassShader::getInstance()->setUniforms(args...);
         glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, (const void*)((SolidPassCmd::getInstance()->Offset[T::MaterialType] + i) * sizeof(DrawElementsIndirectCommand)));
@@ -412,25 +525,15 @@ template<typename T, int...List>
 void renderMeshes2ndPass( const std::vector<uint64_t> &Prefilled_Handle,
     const std::vector<GLuint> &Prefilled_Tex)
 {
-    const std::vector<size_t> &TexUnits = T::SecondPassTextures;
     auto &meshes = T::List::getInstance()->SolidPass;
     glUseProgram(T::SecondPassShader::getInstance()->Program);
     if (irr_driver->hasARB_base_instance())
         glBindVertexArray(VAOManager::getInstance()->getVAO(T::VertexType));
     for (unsigned i = 0; i < meshes.size(); i++)
     {
-        std::vector<uint64_t> Handles(Prefilled_Handle);
-        std::vector<GLuint> Textures(Prefilled_Tex);
         GLMesh &mesh = *(STK::tuple_get<0>(meshes.at(i)));
         if (!irr_driver->hasARB_base_instance())
             glBindVertexArray(mesh.vao);
-        for (unsigned j = 0; j < TexUnits.size(); j++)
-        {
-            if (UserConfigParams::m_azdo)
-                Handles.push_back(mesh.TextureHandles[TexUnits[j]]);
-            else
-                Textures.push_back(getTextureGLuint(mesh.textures[TexUnits[j]]));
-        }
 
         if (mesh.VAOType != T::VertexType)
         {
@@ -441,9 +544,9 @@ void renderMeshes2ndPass( const std::vector<uint64_t> &Prefilled_Handle,
         }
 
         if (UserConfigParams::m_azdo)
-            T::SecondPassShader::getInstance()->SetTextureHandles(Handles);
+            HandleExpander<typename T::SecondPassShader>::template Expand(mesh.TextureHandles, T::SecondPassTextures, Prefilled_Handle[0], Prefilled_Handle[1], Prefilled_Handle[2]);
         else
-            T::SecondPassShader::getInstance()->SetTextureUnits(Textures);
+            TexExpander<typename T::SecondPassShader>::template ExpandTex(mesh, T::SecondPassTextures, Prefilled_Tex[0], Prefilled_Tex[1], Prefilled_Tex[2]);
         custom_unroll_args<List...>::template exec(T::SecondPassShader::getInstance(), meshes.at(i));
     }
 }
@@ -452,29 +555,27 @@ template<typename T, typename...Args>
 void renderInstancedMeshes2ndPass(const std::vector<GLuint> &Prefilled_tex, Args...args)
 {
     std::vector<GLMesh *> &meshes = T::InstancedList::getInstance()->SolidPass;
-    const std::vector<size_t> &TexUnits = T::SecondPassTextures;
     glUseProgram(T::InstancedSecondPassShader::getInstance()->Program);
     glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, T::Instance));
     for (unsigned i = 0; i < meshes.size(); i++)
     {
         GLMesh *mesh = meshes[i];
-        std::vector<GLuint> Textures(Prefilled_tex);
+        TexExpander<typename T::InstancedSecondPassShader>::template ExpandTex(*mesh, T::SecondPassTextures, Prefilled_tex[0], Prefilled_tex[1], Prefilled_tex[2]);
-        for (unsigned j = 0; j < TexUnits.size(); j++)
-            Textures.push_back(getTextureGLuint(mesh->textures[TexUnits[j]]));
-        T::InstancedSecondPassShader::getInstance()->SetTextureUnits(Textures);
         T::InstancedSecondPassShader::getInstance()->setUniforms(args...);
         glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, (const void*)((SolidPassCmd::getInstance()->Offset[T::MaterialType] + i) * sizeof(DrawElementsIndirectCommand)));
     }
 }
 
+
 template<typename T, typename...Args>
 void multidraw2ndPass(const std::vector<uint64_t> &Handles, Args... args)
 {
     glUseProgram(T::InstancedSecondPassShader::getInstance()->Program);
     glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, T::Instance));
+    uint64_t nulltex[10] = {};
     if (SolidPassCmd::getInstance()->Size[T::MaterialType])
     {
-        T::InstancedSecondPassShader::getInstance()->SetTextureHandles(Handles);
+        HandleExpander<typename T::InstancedSecondPassShader>::template Expand(nulltex, T::SecondPassTextures, Handles[0], Handles[1], Handles[2]);
         T::InstancedSecondPassShader::getInstance()->setUniforms(args...);
         glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT,
             (const void*)(SolidPassCmd::getInstance()->Offset[T::MaterialType] * sizeof(DrawElementsIndirectCommand)),
@@ -535,11 +636,25 @@ void IrrDriver::renderSolidSecondPass()
             multidraw2ndPass<AlphaRef>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0));
             multidraw2ndPass<SphereMap>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
             multidraw2ndPass<UnlitMat>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
-            SunLightProvider * const cb = (SunLightProvider *)irr_driver->getCallback(ES_SUNLIGHT);
-            multidraw2ndPass<GrassMat>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, DepthHandle, 0, 0), windDir, cb->getPosition());
-
             multidraw2ndPass<NormalMat>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0));
             multidraw2ndPass<DetailMat>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0, 0));
+
+            // template does not work with template due to extra depth texture
+            {
+                SunLightProvider * const cb = (SunLightProvider *)irr_driver->getCallback(ES_SUNLIGHT);
+                glUseProgram(GrassMat::InstancedSecondPassShader::getInstance()->Program);
+                glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(GrassMat::VertexType, GrassMat::Instance));
+                uint64_t nulltex[10] = {};
+                if (SolidPassCmd::getInstance()->Size[GrassMat::MaterialType])
+                {
+                    HandleExpander<GrassMat::InstancedSecondPassShader>::Expand(nulltex, GrassMat::SecondPassTextures, DiffuseHandle, SpecularHandle, SSAOHandle, DepthHandle);
+                    GrassMat::InstancedSecondPassShader::getInstance()->setUniforms(windDir, cb->getPosition());
+                    glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT,
+                        (const void*)(SolidPassCmd::getInstance()->Offset[GrassMat::MaterialType] * sizeof(DrawElementsIndirectCommand)),
+                        (int)SolidPassCmd::getInstance()->Size[GrassMat::MaterialType],
+                        (int)sizeof(DrawElementsIndirectCommand));
+                }
+            }
         }
         else if (irr_driver->hasARB_draw_indirect())
         {
@@ -547,12 +662,23 @@ void IrrDriver::renderSolidSecondPass()
             renderInstancedMeshes2ndPass<AlphaRef>(DiffSpecSSAOTex);
             renderInstancedMeshes2ndPass<UnlitMat>(DiffSpecSSAOTex);
             renderInstancedMeshes2ndPass<SphereMap>(DiffSpecSSAOTex);
-            SunLightProvider * const cb = (SunLightProvider *)irr_driver->getCallback(ES_SUNLIGHT);
-            DiffSpecSSAOTex.push_back(irr_driver->getDepthStencilTexture());
-            renderInstancedMeshes2ndPass<GrassMat>(DiffSpecSSAOTex, windDir, cb->getPosition());
-            DiffSpecSSAOTex.pop_back();
             renderInstancedMeshes2ndPass<DetailMat>(DiffSpecSSAOTex);
             renderInstancedMeshes2ndPass<NormalMat>(DiffSpecSSAOTex);
+
+            // template does not work with template due to extra depth texture
+            {
+                SunLightProvider * const cb = (SunLightProvider *)irr_driver->getCallback(ES_SUNLIGHT);
+                std::vector<GLMesh *> &meshes = GrassMat::InstancedList::getInstance()->SolidPass;
+                glUseProgram(GrassMat::InstancedSecondPassShader::getInstance()->Program);
+                glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(GrassMat::VertexType, GrassMat::Instance));
+                for (unsigned i = 0; i < meshes.size(); i++)
+                {
+                    GLMesh *mesh = meshes[i];
+                    TexExpander<GrassMat::InstancedSecondPassShader>::ExpandTex(*mesh, GrassMat::SecondPassTextures, DiffSpecSSAOTex[0], DiffSpecSSAOTex[1], DiffSpecSSAOTex[2], irr_driver->getDepthStencilTexture());
+                    GrassMat::InstancedSecondPassShader::getInstance()->setUniforms(windDir, cb->getPosition());
+                    glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, (const void*)((SolidPassCmd::getInstance()->Offset[GrassMat::MaterialType] + i) * sizeof(DrawElementsIndirectCommand)));
+                }
+            }
         }
     }
 }
@@ -597,28 +723,9 @@ void renderTransparenPass(const std::vector<TexUnit> &TexUnits, std::vector<STK:
         glBindVertexArray(VAOManager::getInstance()->getVAO(VertexType));
     for (unsigned i = 0; i < meshes->size(); i++)
     {
-        std::vector<uint64_t> Handles;
-        std::vector<GLuint> Textures;
         GLMesh &mesh = *(STK::tuple_get<0>(meshes->at(i)));
         if (!irr_driver->hasARB_base_instance())
             glBindVertexArray(mesh.vao);
-        for (unsigned j = 0; j < TexUnits.size(); j++)
-        {
-            if (!mesh.textures[TexUnits[j].m_id])
-                mesh.textures[TexUnits[j].m_id] = getUnicolorTexture(video::SColor(255, 255, 255, 255));
-            compressTexture(mesh.textures[TexUnits[j].m_id], TexUnits[j].m_premul_alpha);
-            if (UserConfigParams::m_azdo)
-            {
-                if (!mesh.TextureHandles[TexUnits[j].m_id])
-                    mesh.TextureHandles[TexUnits[j].m_id] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[TexUnits[j].m_id]), Shader::getInstance()->SamplersId[Handles.size()]);
-                if (!glIsTextureHandleResidentARB(mesh.TextureHandles[TexUnits[j].m_id]))
-                    glMakeTextureHandleResidentARB(mesh.TextureHandles[TexUnits[j].m_id]);
-                Handles.push_back(mesh.TextureHandles[TexUnits[j].m_id]);
-            }
-            else
-                Textures.push_back(getTextureGLuint(mesh.textures[TexUnits[j].m_id]));
-        }
-
         if (mesh.VAOType != VertexType)
         {
 #ifdef DEBUG
@@ -628,9 +735,9 @@ void renderTransparenPass(const std::vector<TexUnit> &TexUnits, std::vector<STK:
         }
 
         if (UserConfigParams::m_azdo)
-            Shader::getInstance()->SetTextureHandles(Handles);
+            Shader::getInstance()->SetTextureHandles(mesh.TextureHandles[0]);
         else
-            Shader::getInstance()->SetTextureUnits(Textures);
+            Shader::getInstance()->SetTextureUnits(getTextureGLuint(mesh.textures[0]));
         custom_unroll_args<List...>::template exec(Shader::getInstance(), meshes->at(i));
     }
 }
@@ -741,10 +848,10 @@ void IrrDriver::renderTransparent()
         size_t count = mesh.IndexCount;
         // Render the effect
         MeshShader::DisplaceShader::getInstance()->SetTextureUnits(
-            createVector<GLuint>(getTextureGLuint(displaceTex),
+            getTextureGLuint(displaceTex),
-                irr_driver->getRenderTargetTexture(RTT_COLOR),
+            irr_driver->getRenderTargetTexture(RTT_COLOR),
-                irr_driver->getRenderTargetTexture(RTT_TMP1),
+            irr_driver->getRenderTargetTexture(RTT_TMP1),
-                getTextureGLuint(mesh.textures[0])));
+            getTextureGLuint(mesh.textures[0]));
         glUseProgram(MeshShader::DisplaceShader::getInstance()->Program);
         MeshShader::DisplaceShader::getInstance()->setUniforms(AbsoluteTransformation,
             core::vector2df(cb->getDirX(), cb->getDirY()),
@@ -795,67 +902,55 @@ struct shadow_custom_unroll_args<N, List...>
     }
 };
 
-template<typename T, enum video::E_VERTEX_TYPE VertexType, int...List, typename... Args>
+template<typename T, int...List>
-void renderShadow(const std::vector<GLuint> TextureUnits, unsigned cascade, const std::vector<STK::Tuple<Args...> > &t)
+void renderShadow(unsigned cascade)
 {
-    glUseProgram(T::getInstance()->Program);
+    auto &t = T::List::getInstance()->Shadows[cascade];
+    glUseProgram(T::ShadowPassShader::getInstance()->Program);
     if (irr_driver->hasARB_base_instance())
-        glBindVertexArray(VAOManager::getInstance()->getVAO(VertexType));
+        glBindVertexArray(VAOManager::getInstance()->getVAO(T::VertexType));
     for (unsigned i = 0; i < t.size(); i++)
     {
-        std::vector<uint64_t> Handles;
-        std::vector<GLuint> Textures;
         GLMesh *mesh = STK::tuple_get<0>(t.at(i));
         if (!irr_driver->hasARB_base_instance())
             glBindVertexArray(mesh->vao);
-        for (unsigned j = 0; j < TextureUnits.size(); j++)
-        {
-            compressTexture(mesh->textures[TextureUnits[j]], true);
-            if (UserConfigParams::m_azdo)
-                Handles.push_back(mesh->TextureHandles[TextureUnits[j]]);
-            else
-                Textures.push_back(getTextureGLuint(mesh->textures[TextureUnits[j]]));
-        }
         if (UserConfigParams::m_azdo)
-            T::getInstance()->SetTextureHandles(Handles);
+            HandleExpander<typename T::ShadowPassShader>::template Expand(mesh->TextureHandles, T::ShadowTextures);
         else
-            T::getInstance()->SetTextureUnits(Textures);
+            TexExpander<typename T::ShadowPassShader>::template ExpandTex(*mesh, T::ShadowTextures);
-        shadow_custom_unroll_args<List...>::template exec<T>(T::getInstance(), cascade, t.at(i));
+        shadow_custom_unroll_args<List...>::template exec<typename T::ShadowPassShader>(T::ShadowPassShader::getInstance(), cascade, t.at(i));
     }
 }
 
-template<typename Shader, Material::ShaderType Mat, video::E_VERTEX_TYPE VT, typename...Args>
+template<typename T, typename...Args>
-void renderInstancedShadow(const std::vector<GLuint> TextureUnits, unsigned cascade, const std::vector<GLMesh *> &t, Args ...args)
+void renderInstancedShadow(unsigned cascade, Args ...args)
 {
-    glUseProgram(Shader::getInstance()->Program);
+    glUseProgram(T::InstancedShadowPassShader::getInstance()->Program);
-    glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(VT, InstanceTypeShadow));
+    glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, InstanceTypeShadow));
+    std::vector<GLMesh *> &t = T::InstancedList::getInstance()->Shadows[cascade];
     for (unsigned i = 0; i < t.size(); i++)
     {
-        std::vector<uint64_t> Handles;
-        std::vector<GLuint> Textures;
         GLMesh *mesh = t[i];
 
-        for (unsigned j = 0; j < TextureUnits.size(); j++)
+        TexExpander<typename T::InstancedShadowPassShader>::template ExpandTex(*mesh, T::ShadowTextures);
-            Textures.push_back(getTextureGLuint(mesh->textures[TextureUnits[j]]));
+        T::InstancedShadowPassShader::getInstance()->setUniforms(cascade, args...);
-
+        size_t tmp = ShadowPassCmd::getInstance()->Offset[cascade][T::MaterialType] + i;
-        Shader::getInstance()->SetTextureUnits(Textures);
-        Shader::getInstance()->setUniforms(cascade, args...);
-        size_t tmp = ShadowPassCmd::getInstance()->Offset[cascade][Mat] + i;
         glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, (const void*)((tmp) * sizeof(DrawElementsIndirectCommand)));
     }
+
 }
 
-template<typename Shader, Material::ShaderType Mat, video::E_VERTEX_TYPE VT, typename...Args>
+template<typename T, typename...Args>
 static void multidrawShadow(unsigned i, Args ...args)
 {
-    glUseProgram(Shader::getInstance()->Program);
+    glUseProgram(T::InstancedShadowPassShader::getInstance()->Program);
-    glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(VT, InstanceTypeShadow));
+    glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, InstanceTypeShadow));
-    if (ShadowPassCmd::getInstance()->Size[i][Mat])
+    if (ShadowPassCmd::getInstance()->Size[i][T::MaterialType])
     {
-        Shader::getInstance()->setUniforms(i, args...);
+        T::InstancedShadowPassShader::getInstance()->setUniforms(i, args...);
         glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, 
-            (const void*)(ShadowPassCmd::getInstance()->Offset[i][Mat] * sizeof(DrawElementsIndirectCommand)), 
+            (const void*)(ShadowPassCmd::getInstance()->Offset[i][T::MaterialType] * sizeof(DrawElementsIndirectCommand)),
-            (int)ShadowPassCmd::getInstance()->Size[i][Mat], sizeof(DrawElementsIndirectCommand));
+            (int)ShadowPassCmd::getInstance()->Size[i][T::MaterialType], sizeof(DrawElementsIndirectCommand));
     }
 }
 
@@ -875,37 +970,36 @@ void IrrDriver::renderShadows()
     for (unsigned cascade = 0; cascade < 4; cascade++)
     {
         ScopedGPUTimer Timer(getGPUTimer(Q_SHADOWS_CASCADE0 + cascade));
-        std::vector<GLuint> noTexUnits;
 
-        renderShadow<MeshShader::ShadowShader, video::EVT_STANDARD, 1>(noTexUnits, cascade, ListMatDefault::getInstance()->Shadows[cascade]);
+        renderShadow<DefaultMaterial, 1>(cascade);
-        renderShadow<MeshShader::ShadowShader, video::EVT_STANDARD, 1>(noTexUnits, cascade, ListMatSphereMap::getInstance()->Shadows[cascade]);
+        renderShadow<SphereMap, 1>(cascade);
-        renderShadow<MeshShader::ShadowShader, video::EVT_2TCOORDS, 1>(noTexUnits, cascade, ListMatDetails::getInstance()->Shadows[cascade]);
+        renderShadow<DetailMat, 1>(cascade);
-        renderShadow<MeshShader::ShadowShader, video::EVT_2TCOORDS, 1>(noTexUnits, cascade, ListMatSplatting::getInstance()->Shadows[cascade]);
+        renderShadow<SplattingMat, 1>(cascade);
-        renderShadow<MeshShader::ShadowShader, video::EVT_TANGENTS, 1>(noTexUnits, cascade, ListMatNormalMap::getInstance()->Shadows[cascade]);
+        renderShadow<NormalMat, 1>(cascade);
-        renderShadow<MeshShader::RefShadowShader, video::EVT_STANDARD, 1>(std::vector<GLuint>{ 0 }, cascade, ListMatAlphaRef::getInstance()->Shadows[cascade]);
+        renderShadow<AlphaRef, 1>(cascade);
-        renderShadow<MeshShader::RefShadowShader, video::EVT_STANDARD, 1>(std::vector<GLuint>{ 0 }, cascade, ListMatUnlit::getInstance()->Shadows[cascade]);
+        renderShadow<UnlitMat, 1>(cascade);
-        renderShadow<MeshShader::GrassShadowShader, video::EVT_STANDARD, 3, 1>(std::vector<GLuint>{ 0 }, cascade, ListMatGrass::getInstance()->Shadows[cascade]);
+        renderShadow<GrassMat, 3, 1>(cascade);
 
         if (irr_driver->hasARB_draw_indirect())
             glBindBuffer(GL_DRAW_INDIRECT_BUFFER, ShadowPassCmd::getInstance()->drawindirectcmd);
 
         if (UserConfigParams::m_azdo)
         {
-            multidrawShadow<MeshShader::InstancedShadowShader, Material::SHADERTYPE_SOLID, video::EVT_STANDARD>(cascade);
+            multidrawShadow<DefaultMaterial>(cascade);
-            multidrawShadow<MeshShader::InstancedShadowShader, Material::SHADERTYPE_DETAIL_MAP, video::EVT_2TCOORDS>(cascade);
+            multidrawShadow<DetailMat>(cascade);
-            multidrawShadow<MeshShader::InstancedShadowShader, Material::SHADERTYPE_NORMAL_MAP, video::EVT_TANGENTS>(cascade);
+            multidrawShadow<NormalMat>(cascade);
-            multidrawShadow<MeshShader::InstancedRefShadowShader, Material::SHADERTYPE_ALPHA_TEST, video::EVT_STANDARD>(cascade);
+            multidrawShadow<AlphaRef>(cascade);
-            multidrawShadow<MeshShader::InstancedRefShadowShader, Material::SHADERTYPE_SOLID_UNLIT, video::EVT_STANDARD>(cascade);
+            multidrawShadow<UnlitMat>(cascade);
-            multidrawShadow<MeshShader::InstancedGrassShadowShader, Material::SHADERTYPE_VEGETATION, video::EVT_STANDARD>(cascade, windDir);
+            multidrawShadow<GrassMat>(cascade, windDir);
         }
         else if (irr_driver->hasARB_draw_indirect())
         {
-            renderInstancedShadow<MeshShader::InstancedShadowShader, Material::SHADERTYPE_SOLID, video::EVT_STANDARD>(noTexUnits, cascade, ListInstancedMatDefault::getInstance()->Shadows[cascade]);
+            renderInstancedShadow<DefaultMaterial>(cascade);
-            renderInstancedShadow<MeshShader::InstancedShadowShader, Material::SHADERTYPE_DETAIL_MAP, video::EVT_2TCOORDS>(noTexUnits, cascade, ListInstancedMatDetails::getInstance()->Shadows[cascade]);
+            renderInstancedShadow<DetailMat>(cascade);
-            renderInstancedShadow<MeshShader::InstancedRefShadowShader, Material::SHADERTYPE_ALPHA_TEST, video::EVT_STANDARD>(std::vector < GLuint > { 0 }, cascade, ListInstancedMatAlphaRef::getInstance()->Shadows[cascade]);
+            renderInstancedShadow<AlphaRef>(cascade);
-            renderInstancedShadow<MeshShader::InstancedRefShadowShader, Material::SHADERTYPE_SOLID_UNLIT, video::EVT_STANDARD>(std::vector < GLuint > { 0 }, cascade, ListInstancedMatUnlit::getInstance()->Shadows[cascade]);
+            renderInstancedShadow<UnlitMat>(cascade);
-            renderInstancedShadow<MeshShader::InstancedGrassShadowShader, Material::SHADERTYPE_VEGETATION, video::EVT_STANDARD>(std::vector < GLuint > { 0 }, cascade, ListInstancedMatGrass::getInstance()->Shadows[cascade], windDir);
+            renderInstancedShadow<GrassMat>(cascade, windDir);
-            renderInstancedShadow<MeshShader::InstancedShadowShader, Material::SHADERTYPE_NORMAL_MAP, video::EVT_TANGENTS>(noTexUnits, cascade, ListInstancedMatNormalMap::getInstance()->Shadows[cascade]);
+            renderInstancedShadow<NormalMat>(cascade);
         }
     }
 
@@ -937,56 +1031,55 @@ struct rsm_custom_unroll_args<N, List...>
     }
 };
 
-template<typename T, enum video::E_VERTEX_TYPE VertexType, int... Selector, typename... Args>
+template<typename T, int... Selector>
-void drawRSM(const core::matrix4 & rsm_matrix, const std::vector<GLuint> &TextureUnits, const std::vector<STK::Tuple<Args...> > &t)
+void drawRSM(const core::matrix4 & rsm_matrix)
 {
-    glUseProgram(T::getInstance()->Program);
+    glUseProgram(T::RSMShader::getInstance()->Program);
     if (irr_driver->hasARB_base_instance())
-        glBindVertexArray(VAOManager::getInstance()->getVAO(VertexType));
+        glBindVertexArray(VAOManager::getInstance()->getVAO(T::VertexType));
+    auto t = T::List::getInstance()->RSM;
     for (unsigned i = 0; i < t.size(); i++)
     {
         std::vector<GLuint> Textures;
         GLMesh *mesh = STK::tuple_get<0>(t.at(i));
         if (!irr_driver->hasARB_base_instance())
             glBindVertexArray(mesh->vao);
-        for (unsigned j = 0; j < TextureUnits.size(); j++)
+        if (UserConfigParams::m_azdo)
-            Textures.push_back(getTextureGLuint(mesh->textures[TextureUnits[j]]));
+            HandleExpander<typename T::RSMShader>::template Expand(mesh->TextureHandles, T::RSMTextures);
-        T::getInstance()->SetTextureUnits(Textures);
+        else
-        rsm_custom_unroll_args<Selector...>::template exec<T>(rsm_matrix, t.at(i));
+            TexExpander<typename T::RSMShader>::template ExpandTex(*mesh, T::RSMTextures);
+        rsm_custom_unroll_args<Selector...>::template exec<typename T::RSMShader>(rsm_matrix, t.at(i));
     }
 }
 
-template<typename Shader, Material::ShaderType Mat, video::E_VERTEX_TYPE VT, typename...Args>
+template<typename T, typename...Args>
-void renderRSMShadow(const std::vector<GLuint> TextureUnits, const std::vector<GLMesh *> &t, Args ...args)
+void renderRSMShadow(Args ...args)
 {
-    glUseProgram(Shader::getInstance()->Program);
+    glUseProgram(T::InstancedRSMShader::getInstance()->Program);
-    glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(VT, InstanceTypeRSM));
+    glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, InstanceTypeRSM));
+    auto t = T::InstancedList::getInstance()->RSM;
     for (unsigned i = 0; i < t.size(); i++)
     {
-        std::vector<uint64_t> Handles;
         std::vector<GLuint> Textures;
         GLMesh *mesh = t[i];
 
-        for (unsigned j = 0; j < TextureUnits.size(); j++)
+        TexExpander<typename T::InstancedRSMShader>::template ExpandTex(*mesh, T::RSMTextures);
-            Textures.push_back(getTextureGLuint(mesh->textures[TextureUnits[j]]));
+        T::InstancedRSMShader::getInstance()->setUniforms(args...);
-
+        glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, (const void*)((RSMPassCmd::getInstance()->Offset[T::MaterialType] + i)* sizeof(DrawElementsIndirectCommand)));
-        Shader::getInstance()->SetTextureUnits(Textures);
-        Shader::getInstance()->setUniforms(args...);
-        glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, (const void*)((RSMPassCmd::getInstance()->Offset[Mat] + i)* sizeof(DrawElementsIndirectCommand)));
     }
 }
 
-template<typename Shader, Material::ShaderType Mat, enum video::E_VERTEX_TYPE VertexType, typename... Args>
+template<typename T, typename... Args>
 void multidrawRSM(Args...args)
 {
-    glUseProgram(Shader::getInstance()->Program);
+    glUseProgram(T::InstancedRSMShader::getInstance()->Program);
-    glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(VertexType, InstanceTypeRSM));
+    glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, InstanceTypeRSM));
-    if (RSMPassCmd::getInstance()->Size[Mat])
+    if (RSMPassCmd::getInstance()->Size[T::MaterialType])
     {
-        Shader::getInstance()->setUniforms(args...);
+        T::InstancedRSMShader::getInstance()->setUniforms(args...);
-        glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, 
+        glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT,
-            (const void*)(RSMPassCmd::getInstance()->Offset[Mat] * sizeof(DrawElementsIndirectCommand)), 
+            (const void*)(RSMPassCmd::getInstance()->Offset[T::MaterialType] * sizeof(DrawElementsIndirectCommand)),
-            (int)RSMPassCmd::getInstance()->Size[Mat], sizeof(DrawElementsIndirectCommand));
+            (int)RSMPassCmd::getInstance()->Size[T::MaterialType], sizeof(DrawElementsIndirectCommand));
     }
 }
 
@@ -996,30 +1089,30 @@ void IrrDriver::renderRSM()
     m_rtts->getRSM().Bind();
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-    drawRSM<MeshShader::RSMShader, video::EVT_STANDARD, 3, 1>(rsm_matrix, std::vector<GLuint>{ 0 }, ListMatDefault::getInstance()->RSM);
+    drawRSM<DefaultMaterial, 3, 1>(rsm_matrix);
-    drawRSM<MeshShader::RSMShader, video::EVT_STANDARD, 3, 1>(rsm_matrix, std::vector<GLuint>{ 0 }, ListMatAlphaRef::getInstance()->RSM);
+    drawRSM<AlphaRef, 3, 1>(rsm_matrix);
-    drawRSM<MeshShader::RSMShader, video::EVT_TANGENTS, 3, 1>(rsm_matrix, std::vector<GLuint>{ 0 }, ListMatNormalMap::getInstance()->RSM);
+    drawRSM<NormalMat, 3, 1>(rsm_matrix);
-    drawRSM<MeshShader::RSMShader, video::EVT_STANDARD, 3, 1>(rsm_matrix, std::vector<GLuint>{ 0 }, ListMatUnlit::getInstance()->RSM);
+    drawRSM<UnlitMat, 3, 1>(rsm_matrix);
-    drawRSM<MeshShader::RSMShader, video::EVT_2TCOORDS, 3, 1>(rsm_matrix, std::vector<GLuint>{ 0 }, ListMatDetails::getInstance()->RSM);
+    drawRSM<DetailMat, 3, 1>(rsm_matrix);
-    drawRSM<MeshShader::SplattingRSMShader, video::EVT_2TCOORDS, 1>(rsm_matrix, createVector<GLuint>(1, 2, 3, 4, 5), ListMatSplatting::getInstance()->RSM);
+    drawRSM<SplattingMat, 1>(rsm_matrix);
 
     if (irr_driver->hasARB_draw_indirect())
         glBindBuffer(GL_DRAW_INDIRECT_BUFFER, RSMPassCmd::getInstance()->drawindirectcmd);
 
     if (UserConfigParams::m_azdo)
     {
-        multidrawRSM<MeshShader::InstancedRSMShader, Material::SHADERTYPE_SOLID, video::EVT_STANDARD>(rsm_matrix);
+        multidrawRSM<DefaultMaterial>(rsm_matrix);
-        multidrawRSM<MeshShader::InstancedRSMShader, Material::SHADERTYPE_NORMAL_MAP, video::EVT_TANGENTS>(rsm_matrix);
+        multidrawRSM<NormalMat>(rsm_matrix);
-        multidrawRSM<MeshShader::InstancedRSMShader, Material::SHADERTYPE_ALPHA_TEST, video::EVT_STANDARD>(rsm_matrix);
+        multidrawRSM<AlphaRef>(rsm_matrix);
-        multidrawRSM<MeshShader::InstancedRSMShader, Material::SHADERTYPE_SOLID_UNLIT, video::EVT_STANDARD>(rsm_matrix);
+        multidrawRSM<UnlitMat>(rsm_matrix);
-        multidrawRSM<MeshShader::InstancedRSMShader, Material::SHADERTYPE_DETAIL_MAP, video::EVT_2TCOORDS>(rsm_matrix);
+        multidrawRSM<DetailMat>(rsm_matrix);
     }
     else if (irr_driver->hasARB_draw_indirect())
     {
-        renderRSMShadow<MeshShader::InstancedRSMShader, Material::SHADERTYPE_SOLID, video::EVT_STANDARD>(std::vector < GLuint > { 0 }, ListInstancedMatDefault::getInstance()->RSM, rsm_matrix);
+        renderRSMShadow<DefaultMaterial>(rsm_matrix);
-        renderRSMShadow<MeshShader::InstancedRSMShader, Material::SHADERTYPE_ALPHA_TEST, video::EVT_STANDARD>(std::vector < GLuint > { 0 }, ListInstancedMatAlphaRef::getInstance()->RSM, rsm_matrix);
+        renderRSMShadow<AlphaRef>(rsm_matrix);
-        renderRSMShadow<MeshShader::InstancedRSMShader, Material::SHADERTYPE_SOLID_UNLIT, video::EVT_STANDARD>(std::vector < GLuint > { 0 }, ListInstancedMatUnlit::getInstance()->RSM, rsm_matrix);
+        renderRSMShadow<UnlitMat>(rsm_matrix);
-        renderRSMShadow<MeshShader::InstancedRSMShader, Material::SHADERTYPE_NORMAL_MAP, video::EVT_TANGENTS>(std::vector < GLuint > { 0 }, ListInstancedMatNormalMap::getInstance()->RSM, rsm_matrix);
+        renderRSMShadow<NormalMat>(rsm_matrix);
-        renderRSMShadow<MeshShader::InstancedRSMShader, Material::SHADERTYPE_DETAIL_MAP, video::EVT_2TCOORDS>(std::vector < GLuint > { 0 }, ListInstancedMatDetails::getInstance()->RSM, rsm_matrix);
+        renderRSMShadow<DetailMat>(rsm_matrix);
     }
 }

src/graphics/render_lighting.cpp

@@ -29,7 +29,7 @@ static void renderPointLights(unsigned count)
     glBindBuffer(GL_ARRAY_BUFFER, LightShader::PointLightShader::getInstance()->vbo);
     glBufferSubData(GL_ARRAY_BUFFER, 0, count * sizeof(LightShader::PointLightInfo), PointLightsInfo);
 
-    LightShader::PointLightShader::getInstance()->SetTextureUnits(createVector<GLuint>(irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), irr_driver->getDepthStencilTexture()));
+    LightShader::PointLightShader::getInstance()->SetTextureUnits(irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), irr_driver->getDepthStencilTexture());
     LightShader::PointLightShader::getInstance()->setUniforms();
 
     glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, count);
@@ -120,7 +120,7 @@ void IrrDriver::renderLights(unsigned pointlightcount, bool hasShadow)
         {
             glUseProgram(FullScreenShader::NVWorkaroundRadianceHintsConstructionShader::getInstance()->Program);
             FullScreenShader::NVWorkaroundRadianceHintsConstructionShader::getInstance()->SetTextureUnits(
-                createVector<GLuint>(m_rtts->getRSM().getRTT()[0], m_rtts->getRSM().getRTT()[1], m_rtts->getRSM().getDepthTexture()));
+                m_rtts->getRSM().getRTT()[0], m_rtts->getRSM().getRTT()[1], m_rtts->getRSM().getDepthTexture());
             for (unsigned i = 0; i < 32; i++)
             {
                 FullScreenShader::NVWorkaroundRadianceHintsConstructionShader::getInstance()->setUniforms(rsm_matrix, rh_matrix, rh_extend, i, video::SColorf(cb->getRed(), cb->getGreen(), cb->getBlue()));
@@ -131,11 +131,9 @@ void IrrDriver::renderLights(unsigned pointlightcount, bool hasShadow)
         {
             glUseProgram(FullScreenShader::RadianceHintsConstructionShader::getInstance()->Program);
             FullScreenShader::RadianceHintsConstructionShader::getInstance()->SetTextureUnits(
-                createVector<GLuint>(
                     m_rtts->getRSM().getRTT()[0],
                     m_rtts->getRSM().getRTT()[1],
                     m_rtts->getRSM().getDepthTexture()
-                )
             );
             FullScreenShader::RadianceHintsConstructionShader::getInstance()->setUniforms(rsm_matrix, rh_matrix, rh_extend, video::SColorf(cb->getRed(), cb->getGreen(), cb->getBlue()));
             glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, 32);

src/graphics/render_skybox.cpp

@@ -541,7 +541,7 @@ void IrrDriver::renderSkybox(const scene::ICameraSceneNode *camera)
 
     glUseProgram(MeshShader::SkyboxShader::getInstance()->Program);
     MeshShader::SkyboxShader::getInstance()->setUniforms(transform);
-    MeshShader::SkyboxShader::getInstance()->SetTextureUnits(createVector<GLuint>(SkyboxCubeMap));
+    MeshShader::SkyboxShader::getInstance()->SetTextureUnits(SkyboxCubeMap);
 
     glDrawElements(GL_TRIANGLES, 6 * 6, GL_UNSIGNED_INT, 0);
     glBindVertexArray(0);

src/graphics/shaders_util.hpp

@@ -238,7 +238,8 @@ struct CreateSamplers<>
 template<>
 struct BindTexture<>
 {
-    static void exec(const std::vector<unsigned> &TU, const std::vector<unsigned> &TexId, unsigned N)
+    template<int N>
+    static void exec(const std::vector<unsigned> &TU)
     {}
 };
 
@@ -260,10 +261,11 @@ void BindTextureNearest(unsigned TU, unsigned tid);
 template<SamplerType...tp>
 struct BindTexture<Nearest_Filtered, tp...>
 {
-    static void exec(const std::vector<unsigned> &TU, const std::vector<unsigned> &TexId, unsigned N)
+    template<int N, typename...Args>
+    static void exec(const std::vector<unsigned> &TU, GLuint TexId, Args... args)
     {
-        BindTextureNearest(TU[N], TexId[N]);
+        BindTextureNearest(TU[N], TexId);
-        BindTexture<tp...>::exec(TU, TexId, N + 1);
+        BindTexture<tp...>::template exec<N + 1>(TU, args...);
     }
 };
 
@@ -289,16 +291,17 @@ struct CreateSamplers<Neared_Clamped_Filtered, tp...>
 template<SamplerType...tp>
 struct BindTexture<Neared_Clamped_Filtered, tp...>
 {
-    static void exec(const std::vector<unsigned> &TU, const std::vector<unsigned> &TexId, unsigned N)
+    template<int N, typename...Args>
+    static void exec(const std::vector<unsigned> &TU, GLuint TexId, Args... args)
     {
         glActiveTexture(GL_TEXTURE0 + TU[N]);
-        glBindTexture(GL_TEXTURE_2D, TexId[N]);
+        glBindTexture(GL_TEXTURE_2D, TexId);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.);
-        BindTexture<tp...>::exec(TU, TexId, N + 1);
+        BindTexture<tp...>::template exec<N + 1>(TU, args...);
     }
 };
 
@@ -320,10 +323,11 @@ void BindTextureBilinear(unsigned TU, unsigned tex);
 template<SamplerType...tp>
 struct BindTexture<Bilinear_Filtered, tp...>
 {
-    static void exec(const std::vector<unsigned> &TU, const std::vector<unsigned> &TexId, unsigned N)
+    template<int N, typename...Args>
+    static void exec(const std::vector<unsigned> &TU, GLuint TexId, Args... args)
     {
-        BindTextureBilinear(TU[N], TexId[N]);
+        BindTextureBilinear(TU[N], TexId);
-        BindTexture<tp...>::exec(TU, TexId, N + 1);
+        BindTexture<tp...>::template exec<N + 1>(TU, args...);
     }
 };
 
@@ -345,10 +349,11 @@ void BindTextureBilinearClamped(unsigned TU, unsigned tex);
 template<SamplerType...tp>
 struct BindTexture<Bilinear_Clamped_Filtered, tp...>
 {
-    static void exec(const std::vector<unsigned> &TU, const std::vector<unsigned> &TexId, unsigned N)
+    template<int N, typename...Args>
+    static void exec(const std::vector<unsigned> &TU, GLuint TexId, Args... args)
     {
-        BindTextureBilinearClamped(TU[N], TexId[N]);
+        BindTextureBilinearClamped(TU[N], TexId);
-        BindTexture<tp...>::exec(TU, TexId, N + 1);
+        BindTexture<tp...>::template exec<N + 1>(TU, args...);
     }
 };
 
@@ -370,10 +375,11 @@ void BindTextureSemiTrilinear(unsigned TU, unsigned tex);
 template<SamplerType...tp>
 struct BindTexture<Semi_trilinear, tp...>
 {
-    static void exec(const std::vector<unsigned> &TU, const std::vector<unsigned> &TexId, unsigned N)
+    template<int N, typename...Args>
+    static void exec(const std::vector<unsigned> &TU, GLuint TexId, Args... args)
     {
-        BindTextureSemiTrilinear(TU[N], TexId[N]);
+        BindTextureSemiTrilinear(TU[N], TexId);
-        BindTexture<tp...>::exec(TU, TexId, N + 1);
+        BindTexture<tp...>::template exec<N + 1>(TU, args...);
     }
 };
 
@@ -408,20 +414,22 @@ void BindCubemapTrilinear(unsigned TU, unsigned tex);
 template<SamplerType...tp>
 struct BindTexture<Trilinear_cubemap, tp...>
 {
-    static void exec(const std::vector<unsigned> &TU, const std::vector<unsigned> &TexId, unsigned N)
+    template<int N, typename...Args>
+    static void exec(const std::vector<unsigned> &TU, GLuint TexId, Args... args)
     {
-        BindCubemapTrilinear(TU[N], TexId[N]);
+        BindCubemapTrilinear(TU[N], TexId);
-        BindTexture<tp...>::exec(TU, TexId, N + 1);
+        BindTexture<tp...>::template exec<N + 1>(TU, args...);
     }
 };
 
 template<SamplerType...tp>
 struct BindTexture<Trilinear_Anisotropic_Filtered, tp...>
 {
-    static void exec(const std::vector<unsigned> &TU, const std::vector<unsigned> &TexId, unsigned N)
+    template<int N, typename...Args>
+    static void exec(const std::vector<unsigned> &TU, GLuint TexId, Args... args)
     {
-        BindTextureTrilinearAnisotropic(TU[N], TexId[N]);
+        BindTextureTrilinearAnisotropic(TU[N], TexId);
-        BindTexture<tp...>::exec(TU, TexId, N + 1);
+        BindTexture<tp...>::template exec<N + 1>(TU, args...);
     }
 };
 
@@ -441,10 +449,11 @@ void BindTextureVolume(unsigned TU, unsigned tex);
 template<SamplerType...tp>
 struct BindTexture<Volume_Linear_Filtered, tp...>
 {
-    static void exec(const std::vector<unsigned> &TU, const std::vector<unsigned> &TexId, unsigned N)
+    template<int N, typename...Args>
+    static void exec(const std::vector<unsigned> &TU, GLuint TexId, Args... args)
     {
-        BindTextureVolume(TU[N], TexId[N]);
+        BindTextureVolume(TU[N], TexId);
-        BindTexture<tp...>::exec(TU, TexId, N + 1);
+        BindTexture<tp...>::template exec<N + 1>(TU, args...);
     }
 };
 
@@ -466,10 +475,11 @@ void BindTextureShadow(unsigned TU, unsigned tex);
 template<SamplerType...tp>
 struct BindTexture<Shadow_Sampler, tp...>
 {
-    static void exec(const std::vector<unsigned> &TU, const std::vector<unsigned> &TexId, unsigned N)
+    template <int N, typename...Args>
+    static void exec(const std::vector<unsigned> &TU, GLuint TexId, Args... args)
     {
-        BindTextureShadow(TU[N], TexId[N]);
+        BindTextureShadow(TU[N], TexId);
-        BindTexture<tp...>::exec(TU, TexId, N + 1);
+        BindTexture<tp...>::template exec<N + 1>(TU, args...);
     }
 };
 
@@ -507,21 +517,44 @@ protected:
         glUseProgram(0);
     }
 
+    template<int N>
+    void SetTextureUnits_impl()
+    {
+        static_assert(N == sizeof...(tp), "Not enough texture set");
+    }
+
+    template<int N, typename... TexIds>
+    void SetTextureUnits_impl(GLuint texid, TexIds... args)
+    {
+        setTextureSampler(TextureType[N], TextureUnits[N], texid, SamplersId[N]);
+        SetTextureUnits_impl<N + 1>(args...);
+    }
+
+
+    template<int N>
+    void SetTextureHandles_impl()
+    {
+        static_assert(N == sizeof...(tp), "Not enough handle set");
+    }
+
+    template<int N, typename... HandlesId>
+    void SetTextureHandles_impl(uint64_t handle, HandlesId... args)
+    {
+        if (handle)
+            glUniformHandleui64ARB(TextureLocation[N], handle);
+        SetTextureHandles_impl<N + 1>(args...);
+    }
+
 public:
     std::vector<GLuint> SamplersId;
-    void SetTextureUnits(const std::vector<GLuint> &args)
+
+    template<typename... TexIds>
+    void SetTextureUnits(TexIds... args)
     {
-        if (args.size() != sizeof...(tp))
-            abort();
         if (getGLSLVersion() >= 330)
-        {
+            SetTextureUnits_impl<0>(args...);
-            for (unsigned i = 0; i < args.size(); i++)
-            {
-                setTextureSampler(TextureType[i], TextureUnits[i], args[i], SamplersId[i]);
-            }
-        }
         else
-            BindTexture<tp...>::exec(TextureUnits, args, 0);
+            BindTexture<tp...>::template exec<0>(TextureUnits, args...);
     }
 
     ~TextureRead()
@@ -530,14 +563,10 @@ public:
             glDeleteSamplers(1, &SamplersId[i]);
     }
 
-    void SetTextureHandles(const std::vector<uint64_t> &args)
+    template<typename... HandlesId>
+    void SetTextureHandles(HandlesId... ids)
     {
-        assert(args.size() == TextureLocation.size() && "Wrong Handle count");
+        SetTextureHandles_impl<0>(ids...);
-        for (unsigned i = 0; i < args.size(); i++)
-        {
-            if (args[i])
-                glUniformHandleui64ARB(TextureLocation[i], args[i]);
-        }
     }
 };
 #endif

src/graphics/shadow.cpp

@@ -50,7 +50,7 @@ Shadow::Shadow(video::ITexture *texture, scene::ISceneNode *node,
     v[3].Normal  = normal;
     buffer->recalculateBoundingBox();
 
-    m_node   = irr_driver->addMesh(m_mesh);
+    m_node   = irr_driver->addMesh(m_mesh, "shadow");
 #ifdef DEBUG
     m_node->setName("shadow");
 #endif

src/graphics/show_curve.cpp

@@ -33,7 +33,7 @@ ShowCurve::ShowCurve(float width, float height,
 {
     m_color = color;
     addEmptyMesh();
-    m_scene_node      = irr_driver->addMesh(m_mesh);
+    m_scene_node      = irr_driver->addMesh(m_mesh, "showcurve");
     // After addMesh ref count is 1 (for the attachment to the
     // scene). We keep a copy here, so increase the ref count.
     m_scene_node->grab();

src/graphics/skid_marks.cpp

@@ -190,7 +190,7 @@ void SkidMarks::update(float dt, bool force_skid_marks,
         new SkidMarkQuads(raycast_right-delta, raycast_right+delta,
                           m_material, m_avoid_z_fighting, custom_color);
     new_mesh->addMeshBuffer(smq_right);
-    scene::IMeshSceneNode *new_node = irr_driver->addMesh(new_mesh);
+    scene::IMeshSceneNode *new_node = irr_driver->addMesh(new_mesh, "skidmark");
     if (STKMeshSceneNode* stkm = dynamic_cast<STKMeshSceneNode*>(new_node))
         stkm->setReloadEachFrame(true);
 #ifdef DEBUG

src/graphics/slip_stream.cpp

@@ -55,7 +55,7 @@ SlipStream::SlipStream(AbstractKart* kart) : MovingTexture(0, 0), m_kart(kart)
     m.MaterialType = video::EMT_TRANSPARENT_ADD_COLOR;
 
     createMesh(m);
-    m_node = irr_driver->addMesh(m_mesh);
+    m_node = irr_driver->addMesh(m_mesh, "splistream");
     m_mesh->drop();
 
 #ifdef DEBUG
@@ -103,7 +103,7 @@ SlipStream::SlipStream(AbstractKart* kart) : MovingTexture(0, 0), m_kart(kart)
         }
         buffer->recalculateBoundingBox();
         m_mesh->setBoundingBox(buffer->getBoundingBox());
-        m_debug_node = irr_driver->addMesh(m_debug_mesh, m_kart->getNode());
+        m_debug_node = irr_driver->addMesh(m_debug_mesh, "splistream_debug", m_kart->getNode());
         m_debug_node->grab();
     }
     else

src/graphics/stk_text_billboard.cpp

@@ -20,7 +20,7 @@ STKTextBillboard::STKTextBillboard(core::stringw text, gui::ScalableFont* font,
     irr::scene::ISceneManager* mgr, irr::s32 id,
     const irr::core::vector3df& position, const irr::core::vector3df& size) :
     STKMeshSceneNode(new scene::SMesh(),
-        parent, irr_driver->getSceneManager(), -1,
+        parent, irr_driver->getSceneManager(), -1, "text_billboard",
         position, core::vector3df(0.0f, 0.0f, 0.0f), size, false)
 {
     m_color_top = color_top;

src/graphics/stkanimatedmesh.cpp

@@ -15,7 +15,7 @@
 using namespace irr;
 
 STKAnimatedMesh::STKAnimatedMesh(irr::scene::IAnimatedMesh* mesh, irr::scene::ISceneNode* parent,
-irr::scene::ISceneManager* mgr, s32 id,
+irr::scene::ISceneManager* mgr, s32 id, const std::string& debug_name,
 const core::vector3df& position,
 const core::vector3df& rotation,
 const core::vector3df& scale) :
@@ -23,6 +23,9 @@ const core::vector3df& scale) :
 {
     isGLInitialized = false;
     isMaterialInitialized = false;
+#ifdef DEBUG
+    m_debug_name = debug_name;
+#endif
 }
 
 STKAnimatedMesh::~STKAnimatedMesh()
@@ -77,7 +80,7 @@ void STKAnimatedMesh::updateNoGL()
         for (u32 i = 0; i < m->getMeshBufferCount(); ++i)
         {
             scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i);
-            GLmeshes.push_back(allocateMeshBuffer(mb));
+            GLmeshes.push_back(allocateMeshBuffer(mb, m_debug_name));
         }
 
         for (u32 i = 0; i < m->getMeshBufferCount(); ++i)
@@ -149,6 +152,8 @@ void STKAnimatedMesh::updateGL()
                 Material::ShaderType MatType = MaterialTypeToMeshMaterial(type, mb->getVertexType(), material, material2);
                 InitTextures(mesh, MatType);
             }
+            else
+                InitTexturesTransparent(mesh);
 
             if (irr_driver->hasARB_base_instance())
             {

src/graphics/stkanimatedmesh.hpp

@@ -19,7 +19,7 @@ public:
     virtual void updateNoGL();
     virtual void updateGL();
   STKAnimatedMesh(irr::scene::IAnimatedMesh* mesh, irr::scene::ISceneNode* parent,
-     irr::scene::ISceneManager* mgr, irr::s32 id,
+     irr::scene::ISceneManager* mgr, irr::s32 id, const std::string& debug_name,
      const irr::core::vector3df& position = irr::core::vector3df(0,0,0),
      const irr::core::vector3df& rotation = irr::core::vector3df(0,0,0),
      const irr::core::vector3df& scale = irr::core::vector3df(1.0f, 1.0f, 1.0f));

src/graphics/stkbillboard.cpp

@@ -52,7 +52,7 @@ void STKBillboard::render()
     compressTexture(tex, true, true);
     GLuint texid = getTextureGLuint(tex);
     glUseProgram(MeshShader::BillboardShader::getInstance()->Program);
-    MeshShader::BillboardShader::getInstance()->SetTextureUnits(createVector<GLuint>(texid));
+    MeshShader::BillboardShader::getInstance()->SetTextureUnits(texid);
     MeshShader::BillboardShader::getInstance()->setUniforms(irr_driver->getViewMatrix(), irr_driver->getProjMatrix(), pos, Size);
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
     glBindVertexArray(0);

src/graphics/stkmesh.cpp

@@ -121,13 +121,17 @@ GLuint createVAO(GLuint vbo, GLuint idx, video::E_VERTEX_TYPE type)
     return vao;
 }
 
-GLMesh allocateMeshBuffer(scene::IMeshBuffer* mb)
+GLMesh allocateMeshBuffer(scene::IMeshBuffer* mb, const std::string& debug_name)
 {
     GLMesh result = {};
     if (!mb)
         return result;
     result.mb = mb;
 
+#ifdef DEBUG
+    result.debug_name = debug_name;
+#endif
+
     result.IndexCount = mb->getIndexCount();
     switch (mb->getIndexType())
     {
@@ -350,3 +354,21 @@ void InitTextures(GLMesh &mesh, Material::ShaderType Mat)
         break;
     }
 }
+
+void InitTexturesTransparent(GLMesh &mesh)
+{
+    if (!mesh.textures[0])
+    {
+        Log::fatal("STKMesh", "Missing texture for material transparent");
+        return;
+    }
+    compressTexture(mesh.textures[0], true);
+    if (UserConfigParams::m_azdo)
+    {
+        if (!mesh.TextureHandles[0])
+            mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::ObjectPass1Shader::getInstance()->SamplersId[0]);
+        if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0]))
+            glMakeTextureHandleResidentARB(mesh.TextureHandles[0]);
+    }
+}
+

src/graphics/stkmesh.hpp

@@ -36,9 +36,12 @@ struct GLMesh {
     video::E_VERTEX_TYPE VAOType;
     uint64_t TextureHandles[6];
     scene::IMeshBuffer *mb;
+#ifdef DEBUG
+    std::string debug_name;
+#endif
 };
 
-GLMesh allocateMeshBuffer(scene::IMeshBuffer* mb);
+GLMesh allocateMeshBuffer(scene::IMeshBuffer* mb, const std::string& debug_name);
 void fillLocalBuffer(GLMesh &, scene::IMeshBuffer* mb);
 video::E_VERTEX_TYPE getVTXTYPEFromStride(size_t stride);
 GLuint createVAO(GLuint vbo, GLuint idx, video::E_VERTEX_TYPE type);
@@ -54,6 +57,8 @@ protected:
     bool m_culledForPlayerCam;
     bool m_culledForShadowCam[4];
     bool m_culledForRSMCam;
+    std::string m_debug_name;
+
 public:
     PtrVector<GLMesh, REF> MeshSolidMaterial[Material::SHADERTYPE_COUNT];
     PtrVector<GLMesh, REF> TransparentMesh[TM_COUNT];
@@ -179,5 +184,6 @@ Material::ShaderType MaterialTypeToMeshMaterial(video::E_MATERIAL_TYPE MaterialT
 TransparentMaterial MaterialTypeToTransparentMaterial(video::E_MATERIAL_TYPE, f32 MaterialTypeParam, Material* material);
 
 void InitTextures(GLMesh &mesh, Material::ShaderType);
+void InitTexturesTransparent(GLMesh &mesh);
 
 #endif // STKMESH_H

src/graphics/stkmeshscenenode.cpp

@@ -14,7 +14,8 @@
 #include "utils/tuple.hpp"
 #include "utils/cpp2011.hpp"
 
-STKMeshSceneNode::STKMeshSceneNode(irr::scene::IMesh* mesh, ISceneNode* parent, irr::scene::ISceneManager* mgr, irr::s32 id,
+STKMeshSceneNode::STKMeshSceneNode(irr::scene::IMesh* mesh, ISceneNode* parent, irr::scene::ISceneManager* mgr,
+    irr::s32 id, const std::string& debug_name,
     const irr::core::vector3df& position,
     const irr::core::vector3df& rotation,
     const irr::core::vector3df& scale, bool createGLMeshes) :
@@ -25,6 +26,8 @@ STKMeshSceneNode::STKMeshSceneNode(irr::scene::IMesh* mesh, ISceneNode* parent,
     update_each_frame = false;
     isGlow = false;
 
+    m_debug_name = debug_name;
+
     if (createGLMeshes)
         this->createGLMeshes();
 }
@@ -41,7 +44,7 @@ void STKMeshSceneNode::createGLMeshes()
     for (u32 i = 0; i<Mesh->getMeshBufferCount(); ++i)
     {
         scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i);
-        GLmeshes.push_back(allocateMeshBuffer(mb));
+        GLmeshes.push_back(allocateMeshBuffer(mb, m_debug_name));
     }
     isMaterialInitialized = false;
     isGLInitialized = false;
@@ -189,6 +192,8 @@ void STKMeshSceneNode::updateGL()
             if (!immediate_draw)
                 InitTextures(mesh, MatType);
         }
+        else if (!immediate_draw)
+            InitTexturesTransparent(mesh);
 
         if (!immediate_draw && irr_driver->hasARB_base_instance())
         {
@@ -268,10 +273,10 @@ void STKMeshSceneNode::render()
                     mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentFogShader::getInstance()->SamplersId[0]);
                 if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0]))
                     glMakeTextureHandleResidentARB(mesh.TextureHandles[0]);
-                MeshShader::ObjectPass1Shader::getInstance()->SetTextureHandles(createVector<uint64_t>(mesh.TextureHandles[0]));
+                MeshShader::ObjectPass1Shader::getInstance()->SetTextureHandles(mesh.TextureHandles[0]);
             }
             else
-                MeshShader::ObjectPass1Shader::getInstance()->SetTextureUnits(std::vector < GLuint > { getTextureGLuint(mesh.textures[0]) });
+                MeshShader::ObjectPass1Shader::getInstance()->SetTextureUnits(getTextureGLuint(mesh.textures[0]));
             MeshShader::ObjectPass1Shader::getInstance()->setUniforms(AbsoluteTransformation, invmodel);
             assert(mesh.vao);
             glBindVertexArray(mesh.vao);
@@ -318,15 +323,19 @@ void STKMeshSceneNode::render()
                     mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentFogShader::getInstance()->SamplersId[0]);
                 if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0]))
                     glMakeTextureHandleResidentARB(mesh.TextureHandles[0]);
-                MeshShader::ObjectPass2Shader::getInstance()->SetTextureHandles(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, mesh.TextureHandles[0]));
+                if (!mesh.TextureHandles[1])
+                    mesh.TextureHandles[1] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[1]), MeshShader::TransparentFogShader::getInstance()->SamplersId[0]);
+                if (!glIsTextureHandleResidentARB(mesh.TextureHandles[1]))
+                    glMakeTextureHandleResidentARB(mesh.TextureHandles[1]);
+                MeshShader::ObjectPass2Shader::getInstance()->SetTextureHandles(DiffuseHandle, SpecularHandle, SSAOHandle, mesh.TextureHandles[0], mesh.TextureHandles[1]);
             }
             else
-                MeshShader::ObjectPass2Shader::getInstance()->SetTextureUnits(createVector<GLuint>(
+                MeshShader::ObjectPass2Shader::getInstance()->SetTextureUnits(
                 irr_driver->getRenderTargetTexture(RTT_DIFFUSE),
                 irr_driver->getRenderTargetTexture(RTT_SPECULAR),
                 irr_driver->getRenderTargetTexture(RTT_HALF1_R),
                 getTextureGLuint(mesh.textures[0]),
-                getTextureGLuint(mesh.textures[1])));
+                getTextureGLuint(mesh.textures[1]));
             MeshShader::ObjectPass2Shader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix);
             assert(mesh.vao);
             glBindVertexArray(mesh.vao);
@@ -395,10 +404,10 @@ void STKMeshSceneNode::render()
                             mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentFogShader::getInstance()->SamplersId[0]);
                         if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0]))
                             glMakeTextureHandleResidentARB(mesh.TextureHandles[0]);
-                        MeshShader::TransparentFogShader::getInstance()->SetTextureHandles(createVector<uint64_t>(mesh.TextureHandles[0]));
+                        MeshShader::TransparentFogShader::getInstance()->SetTextureHandles(mesh.TextureHandles[0]);
                     }
                     else
-                        MeshShader::TransparentFogShader::getInstance()->SetTextureUnits(std::vector<GLuint>{ getTextureGLuint(mesh.textures[0]) });
+                        MeshShader::TransparentFogShader::getInstance()->SetTextureUnits(getTextureGLuint(mesh.textures[0]));
                     MeshShader::TransparentFogShader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix, fogmax, startH, endH, start, end, col);
 
                     assert(mesh.vao);
@@ -425,10 +434,10 @@ void STKMeshSceneNode::render()
                             mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentShader::getInstance()->SamplersId[0]);
                         if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0]))
                             glMakeTextureHandleResidentARB(mesh.TextureHandles[0]);
-                        MeshShader::TransparentShader::getInstance()->SetTextureHandles(createVector<uint64_t>(mesh.TextureHandles[0]));
+                        MeshShader::TransparentShader::getInstance()->SetTextureHandles(mesh.TextureHandles[0]);
                     }
                     else
-                        MeshShader::TransparentShader::getInstance()->SetTextureUnits(std::vector<GLuint>{ getTextureGLuint(mesh.textures[0]) });
+                        MeshShader::TransparentShader::getInstance()->SetTextureUnits(getTextureGLuint(mesh.textures[0]));
 
                     MeshShader::TransparentShader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix);
                     assert(mesh.vao);

src/graphics/stkmeshscenenode.hpp

@@ -29,7 +29,8 @@ public:
     virtual void updateNoGL();
     virtual void updateGL();
     void setReloadEachFrame(bool);
-    STKMeshSceneNode(irr::scene::IMesh* mesh, ISceneNode* parent, irr::scene::ISceneManager* mgr, irr::s32 id,
+    STKMeshSceneNode(irr::scene::IMesh* mesh, ISceneNode* parent, irr::scene::ISceneManager* mgr,
+        irr::s32 id, const std::string& debug_name,
         const irr::core::vector3df& position = irr::core::vector3df(0, 0, 0),
         const irr::core::vector3df& rotation = irr::core::vector3df(0, 0, 0),
         const irr::core::vector3df& scale = irr::core::vector3df(1.0f, 1.0f, 1.0f),

src/guiengine/engine.cpp

@@ -1034,6 +1034,7 @@ namespace GUIEngine
             }
             catch (std::runtime_error& err)
             {
+                (void)err;
                 Log::fatal("Engine::init", "Canot load default GUI skin");
             }
         }

src/guiengine/widgets/model_view_widget.cpp

@@ -208,7 +208,7 @@ void ModelViewWidget::setupRTTScene(PtrVector<scene::IMesh, REF>& mesh,
     else
     {
         scene::IAnimatedMeshSceneNode* node =
-        irr_driver->addAnimatedMesh((scene::IAnimatedMesh*)mesh.get(0), NULL);
+        irr_driver->addAnimatedMesh((scene::IAnimatedMesh*)mesh.get(0), "rtt_mesh", NULL);
         node->setPosition(mesh_location[0].toIrrVector());
         node->setFrameLoop(model_frames[0], model_frames[0]);
         node->setAnimationSpeed(0);
@@ -228,7 +228,7 @@ void ModelViewWidget::setupRTTScene(PtrVector<scene::IMesh, REF>& mesh,
         if (model_frames[n] == -1)
         {
             scene::ISceneNode* node =
-            irr_driver->addMesh(mesh.get(n), m_rtt_main_node);
+            irr_driver->addMesh(mesh.get(n), "rtt_node", m_rtt_main_node);
             node->setPosition(mesh_location[n].toIrrVector());
             node->updateAbsolutePosition();
             node->setScale(mesh_scale[n].toIrrVector());
@@ -237,7 +237,7 @@ void ModelViewWidget::setupRTTScene(PtrVector<scene::IMesh, REF>& mesh,
         {
             scene::IAnimatedMeshSceneNode* node =
             irr_driver->addAnimatedMesh((scene::IAnimatedMesh*)mesh.get(n),
-                                        m_rtt_main_node);
+                                        "modelviewrtt", m_rtt_main_node);
             node->setPosition(mesh_location[n].toIrrVector());
             node->setFrameLoop(model_frames[n], model_frames[n]);
             node->setAnimationSpeed(0);

src/input/binding.cpp

@@ -16,12 +16,14 @@
 //  along with this program; if not, write to the Free Software
 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
-#include <SKeyMap.h>
 #include "input/binding.hpp"
+#include "io/xml_node.hpp"
 #include "utils/string_utils.hpp"
 #include "utils/translation.hpp"
 #include "utils/log.hpp"
 
+#include <SKeyMap.h>
+
 /** Convert thjis binding to XML attributes. The full XML node is actually
  *  written by device_config, so we only have to add the attributes here.
  */
@@ -40,51 +42,37 @@ void Binding::serialize(std::ofstream& stream) const
 }   // serialize
 
 // ----------------------------------------------------------------------------
-bool Binding::deserialize(irr::io::IrrXMLReader* xml)
+bool Binding::load(const XMLNode *action)
 {
-    const char *id_string       = xml->getAttributeValue("id");
+    int n;
-    const char *event_string    = xml->getAttributeValue("event");
+    if(!action->get("id", &m_id) || !action->get("event", &n)  )
-    const char *dir_string      = xml->getAttributeValue("direction");
-    const char *range_string    = xml->getAttributeValue("range");
-    const char *character       = xml->getAttributeValue("character");
-
-    // Proceed only if neccesary tags were found
-    if ((id_string == NULL) ||  (event_string == NULL))
     {
         Log::warn("Binding", "No id-string or event-string given - ignored.");
         return false;
     }
-
+    m_type = (Input::InputType)n;
-    // Convert strings to string tags to integer types
+    core::stringw s;
-    m_type = (Input::InputType)atoi(event_string);
+    m_character = 0;
-    m_id   = atoi(id_string);
+    action->get("character", &s);
-    m_character = character ? atoi(character) : 0;
+    if(s.size()>0)
+        m_character = s[0];
 
     // If the action is not a stick motion (button or key)
     if (m_type == Input::IT_STICKMOTION)
     {
-        // If the action is a stick motion & a direction is defined
+        if(!action->get("direction", &n))
-        if (dir_string == NULL)
         {
             Log::warn("Binding", "IT_STICKMOTION without direction, ignoring.");
             return false;
         }
-        
+        m_dir = (Input::AxisDirection)n;
-        // If the action is a stick motion & a range is defined
+
-        if (range_string == NULL)
+        if(!action->get("range", &n)) m_range = Input::AR_HALF;
-        {
+        else                          m_range = (Input::AxisRange)n;
-            m_range = Input::AR_HALF;
-        }
-        else
-        {
-            m_range = (Input::AxisRange)atoi(range_string);
-        }
-   
-        m_dir   = (Input::AxisDirection)atoi(dir_string);
 
     }   // if m_type!=stickmotion
     return true;
-}   // deserialize
+}   // load
 
 // ----------------------------------------------------------------------------
 /** Returns a string representing this binding, which can be displayed on the

src/input/binding.hpp

@@ -20,17 +20,20 @@
 #ifndef BINDING_HPP
 #define BINDING_HPP
 
-#include <fstream>
 
-#include <irrString.h>
 #include "input/input.hpp"
 #include "utils/no_copy.hpp"
-#include <irrXML.h>
+
+#include "irrString.h"
+
+#include <fstream>
+
+class XMLNode;
 
 /**
   * \ingroup config
   */
-class Binding
+class Binding : public NoCopy
 {
 private:
     Input::InputType        m_type;
@@ -62,7 +65,7 @@ public:
 
     // ------------------------------------------------------------------------
     void               serialize  (std::ofstream& stream) const;
-    bool               deserialize(irr::io::IrrXMLReader* xml);
+    bool               load(const XMLNode *action);
     irr::core::stringw getAsString() const;
 };
 #endif

src/input/device_manager.cpp

@@ -61,7 +61,7 @@ bool DeviceManager::initialize()
         Log::info("-","---------------------------");
     }
 
-    deserialize();
+    load();
 
     // Assign a configuration to the keyboard, or create one if we haven't yet
     if(UserConfigParams::logMisc()) Log::info("Device manager","Initializing keyboard support.");
@@ -437,123 +437,88 @@ void DeviceManager::clearLatestUsedDevice()
 }   // clearLatestUsedDevice
 
 // -----------------------------------------------------------------------------
-bool DeviceManager::deserialize()
+/** Loads the configuration from the user's input.xml file.
+ */
+bool DeviceManager::load()
 {
-    static std::string filepath = file_manager->getUserConfigFile(INPUT_FILE_NAME);
+    std::string filepath = file_manager->getUserConfigFile(INPUT_FILE_NAME);
 
     if(UserConfigParams::logMisc())
-        Log::info("Device manager","Deserializing input.xml...");
+        Log::info("Device manager","Loading input.xml...");
 
-    if(!file_manager->fileExists(filepath))
+    const XMLNode *input = file_manager->createXMLTree(filepath);
+
+    if(!input)
     {
         if(UserConfigParams::logMisc())
             Log::warn("Device manager","No configuration file exists.");
+        return false;
     }
-    else
+
+    if(input->getName()!="input")
     {
-        irr::io::IrrXMLReader* xml = irr::io::createIrrXMLReader( filepath.c_str() );
+        Log::warn("DeviceManager", "Invalid input.xml file - no input node.");
-
+        return false;
-        const int GAMEPAD = 1;
-        const int KEYBOARD = 2;
-        const int NOTHING = 3;
-
-        int reading_now = NOTHING;
-
-        KeyboardConfig* keyboard_config = NULL;
-        GamepadConfig* gamepad_config = NULL;
-
-
-        // parse XML file
-        while(xml && xml->read())
-        {
-            switch(xml->getNodeType())
-            {
-                case irr::io::EXN_TEXT:
-                    break;
-
-                case irr::io::EXN_ELEMENT:
-                {
-                    if (strcmp("input", xml->getNodeName()) == 0)
-                    {
-                        const char *version_string = xml->getAttributeValue("version");
-                        if (version_string == NULL || atoi(version_string) != INPUT_FILE_VERSION)
-                        {
-                            //I18N: shown when config file is too old
-                            GUIEngine::showMessage( _("Please re-configure your key bindings.") );
-
-                            GUIEngine::showMessage( _("Your input config file is not compatible with this version of STK.") );
-                            return false;
-                        }
-                    }
-                    if (strcmp("keyboard", xml->getNodeName()) == 0)
-                    {
-                        keyboard_config = new KeyboardConfig();
-                        reading_now = KEYBOARD;
-                    }
-                    else if (strcmp("gamepad", xml->getNodeName()) == 0)
-                    {
-                        gamepad_config = new GamepadConfig(xml);
-                        reading_now = GAMEPAD;
-                    }
-                    else if (strcmp("action", xml->getNodeName()) == 0)
-                    {
-                        if(reading_now == KEYBOARD)
-                        {
-                            if(keyboard_config != NULL)
-                                if(!keyboard_config->deserializeAction(xml))
-                                    Log::error("Device manager","Ignoring an ill-formed keyboard action in input config.");
-                        }
-                        else if(reading_now == GAMEPAD)
-                        {
-                            if(gamepad_config != NULL)
-                                if(!gamepad_config->deserializeAction(xml))
-                                     Log::error("Device manager","Ignoring an ill-formed gamepad action in input config.");
-                        }
-                        else  Log::warn("Device manager","An action is placed in an unexpected area in the input config file.");
-                    }
-                }
-                break;
-                // ---- section ending
-                case irr::io::EXN_ELEMENT_END:
-                {
-                    if (strcmp("keyboard", xml->getNodeName()) == 0)
-                    {
-                        m_keyboard_configs.push_back(keyboard_config);
-                        reading_now = NOTHING;
-                    }
-                    else if (strcmp("gamepad", xml->getNodeName()) == 0)
-                    {
-                        m_gamepad_configs.push_back(gamepad_config);
-                        reading_now = NOTHING;
-                    }
-                }
-                    break;
-
-                default: break;
-
-            } // end switch
-        } // end while
-
-        if(UserConfigParams::logMisc())
-        {
-            Log::info("Device manager","Found %d keyboard and %d gamepad configurations.",
-                   m_keyboard_configs.size(), m_gamepad_configs.size());
-        }
-
-        // For Debugging....
-        /*
-        for (int n = 0; n < m_keyboard_configs.size(); n++)
-            printf("Config #%d\n%s", n + 1, m_keyboard_configs[n].toString().c_str());
-
-        for (int n = 0; n < m_gamepad_configs.size(); n++)
-            printf("%s", m_gamepad_configs[n].toString().c_str());
-        */
-
-        delete xml;
     }
 
+    int version=0;
+    if(!input->get("version", &version) || version != INPUT_FILE_VERSION )
+    {
+        //I18N: shown when config file is too old
+        GUIEngine::showMessage(_("Please re-configure your key bindings."));
+        GUIEngine::showMessage(_("Your input config file is not compatible "
+                                 "with this version of STK."));
+        return false;
+    }
+
+    for(unsigned int i=0; i<input->getNumNodes(); i++)
+    {
+        const XMLNode *config = input->getNode(i);
+        if(config->getName()=="keyboard")
+        {
+            KeyboardConfig* keyboard_config = new KeyboardConfig();
+            if(!keyboard_config->load(config))
+            {
+                Log::error("Device manager",
+                    "Ignoring an ill-formed keyboard action in input config.");
+            }
+            m_keyboard_configs.push_back(keyboard_config);
+        }
+        else if (config->getName()=="gamepad")
+        {
+            GamepadConfig* gamepad_config = new GamepadConfig(config);
+            gamepad_config->load(config);
+            m_gamepad_configs.push_back(gamepad_config);
+        }
+        else
+        {
+            Log::warn("DeviceManager",
+                      "Invalid node '%s' in input.xml - ignored.",
+                      config->getName().c_str());
+            continue;
+        }
+    }   // for i < getNumNodes
+
+    if (UserConfigParams::logMisc())
+    {
+        Log::info("Device manager",
+                  "Found %d keyboard and %d gamepad configurations.",
+                  m_keyboard_configs.size(), m_gamepad_configs.size());
+    }
+
+    // For Debugging....
+    /*
+    for (int n = 0; n < m_keyboard_configs.size(); n++)
+        printf("Config #%d\n%s", n + 1, m_keyboard_configs[n].toString().c_str());
+
+    for (int n = 0; n < m_gamepad_configs.size(); n++)
+        printf("%s", m_gamepad_configs[n].toString().c_str());
+    */
+
+    delete input;
+
     return true;
-}   // deserialize
+}   // load
 
 // -----------------------------------------------------------------------------
 void DeviceManager::serialize()

src/input/device_manager.hpp

@@ -99,7 +99,7 @@ private:
      *  pressing fire. */
     bool m_map_fire_to_select;
 
-    bool deserialize();
+    bool load();
     void shutdown();
 
 public:

src/items/attachment.cpp

@@ -59,7 +59,7 @@ Attachment::Attachment(AbstractKart* kart)
     // If we attach a NULL mesh, we get a NULL scene node back. So we
     // have to attach some kind of mesh, but make it invisible.
     m_node = irr_driver->addAnimatedMesh(
-                         attachment_manager->getMesh(Attachment::ATTACH_BOMB));
+                         attachment_manager->getMesh(Attachment::ATTACH_BOMB), "bomb");
 #ifdef DEBUG
     std::string debug_name = kart->getIdent()+" (attachment)";
     m_node->setName(debug_name.c_str());
@@ -113,7 +113,7 @@ void Attachment::set(AttachmentType type, float time,
         bomb_scene_node = m_node;
 
         m_node = irr_driver->addAnimatedMesh(
-                     attachment_manager->getMesh(Attachment::ATTACH_BOMB));
+                     attachment_manager->getMesh(Attachment::ATTACH_BOMB), "bomb");
 #ifdef DEBUG
         std::string debug_name = m_kart->getIdent() + " (attachment)";
         m_node->setName(debug_name.c_str());

src/items/flyable.cpp

@@ -74,7 +74,7 @@ Flyable::Flyable(AbstractKart *kart, PowerupManager::PowerupType type,
     m_max_lifespan = -1;
 
     // Add the graphical model
-    setNode(irr_driver->addMesh(m_st_model[type]));
+    setNode(irr_driver->addMesh(m_st_model[type], StringUtils::insertValues("flyable_%i", (int)type)));
     irr_driver->applyObjectPassShader(getNode());
 #ifdef DEBUG
     std::string debug_name("flyable: ");

src/items/item.cpp

@@ -48,12 +48,12 @@ Item::Item(ItemType type, const Vec3& xyz, const Vec3& normal,
     LODNode* lodnode    = new LODNode("item",
                                       irr_driver->getSceneManager()->getRootSceneNode(),
                                       irr_driver->getSceneManager());
-    scene::IMeshSceneNode* meshnode = irr_driver->addMesh(mesh);
+    scene::IMeshSceneNode* meshnode = irr_driver->addMesh(mesh, StringUtils::insertValues("item_%i", (int)type));
 
     if (lowres_mesh != NULL)
     {
         lodnode->add(35, meshnode, true);
-        scene::IMeshSceneNode* meshnode = irr_driver->addMesh(lowres_mesh);
+        scene::IMeshSceneNode* meshnode = irr_driver->addMesh(lowres_mesh, StringUtils::insertValues("item_lo_%i", (int)type));
         lodnode->add(100, meshnode, true);
     }
     else

src/items/rubber_band.cpp

@@ -75,7 +75,7 @@ RubberBand::RubberBand(Plunger *plunger, AbstractKart *kart)
     // Gloss
     mb->getMaterial().setTexture(1, getUnicolorTexture(video::SColor(0, 0, 0, 0)));
     updatePosition();
-    m_node = irr_driver->addMesh(m_mesh);
+    m_node = irr_driver->addMesh(m_mesh, "rubberband");
     irr_driver->applyObjectPassShader(m_node);
     if (STKMeshSceneNode *stkm = dynamic_cast<STKMeshSceneNode *>(m_node))
         stkm->setReloadEachFrame(true);

src/karts/kart.cpp

@@ -1744,7 +1744,7 @@ void Kart::crashed(AbstractKart *k, bool update_attachments)
         getAttachment()->handleCollisionWithKart(k);
     }
     m_controller->crashed(k);
-    crashed(NULL, k);
+    playCrashSFX(NULL, k);
 }   // crashed(Kart, update_attachments
 
 // -----------------------------------------------------------------------------
@@ -1753,6 +1753,7 @@ void Kart::crashed(AbstractKart *k, bool update_attachments)
  */
 void Kart::crashed(const Material *m, const Vec3 &normal)
 {
+    playCrashSFX(m, NULL);
 #ifdef DEBUG
     // Simple debug output for people playing without sound.
     // This makes it easier to see if a kart hit the track (esp.
@@ -1858,26 +1859,33 @@ void Kart::crashed(const Material *m, const Vec3 &normal)
         }
         else if (m->getCollisionReaction() == Material::PUSH_BACK)
         {
-            if (m_bounce_back_time <= 0.2f) // this variable is sometimes set to 0.1 somewhere else
+            // This variable is set to 0.2 in case of a kart-terrain collision
+            if (m_bounce_back_time <= 0.2f)
             {
                 btVector3 push = m_body->getLinearVelocity().normalized();
                 push[1] = 0.1f;
                 m_body->applyCentralImpulse( -4000.0f*push );
                 m_bounce_back_time = 2.0f;
 
-                core::stringw msg = _("You need more points\nto enter this challenge!\nCheck the minimap for\navailable challenges.");
+                core::stringw msg = _("You need more points\n"
-                std::vector<core::stringw> parts = StringUtils::split(msg, '\n', false);
+                                      "to enter this challenge!\n"
+                                      "Check the minimap for\n"
+                                      "available challenges.");
+                std::vector<core::stringw> parts = 
+                    StringUtils::split(msg, '\n', false);
 
-                // For now, until we have scripting, special-case the overworld... (TODO)
+                // For now, until we have scripting, special-case 
+                // the overworld... (TODO)
                 if (dynamic_cast<OverWorld*>(World::getWorld()) != NULL)
                 {
                     SFXManager::get()->quickSound("forcefield");
 
                     for (unsigned int n = 0; n < parts.size(); n++)
                     {
-                        World::getWorld()->getRaceGUI()->addMessage(parts[n], NULL, 4.0f,
+                        World::getWorld()->getRaceGUI()
-                                                                    video::SColor(255, 255,255,255),
+                                         ->addMessage(parts[n], NULL, 4.0f,
-                                                                    true, true);
+                                                      video::SColor(255, 255,255,255),
+                                                       true, true);
                     }   // for n<parts.size()
                 }   // if world exist
             }   // if m_bounce_back_time <= 0.2f
@@ -1885,7 +1893,6 @@ void Kart::crashed(const Material *m, const Vec3 &normal)
     }   // if(m && m->getCollisionReaction() != Material::NORMAL &&
         //   !getKartAnimation())
     m_controller->crashed(m);
-    crashed(m, NULL);
 }   // crashed(Material)
 
 // -----------------------------------------------------------------------------
@@ -1893,7 +1900,7 @@ void Kart::crashed(const Material *m, const Vec3 &normal)
  * @param m The material collided into, or NULL if none
  * @param k The kart collided into, or NULL if none
  */
-void Kart::crashed(const Material* m, AbstractKart *k)
+void Kart::playCrashSFX(const Material* m, AbstractKart *k)
 {
     if(World::getWorld()->getTime()-m_time_last_crash < 0.5f) return;
 
@@ -1917,11 +1924,9 @@ void Kart::crashed(const Material* m, AbstractKart *k)
                 if(m_crash_sound->getStatus() != SFXBase::SFX_PLAYING)
                     m_crash_sound->play();
             }
-        }
+        }    // if lin_vel > 0.555
-
+    }   // if m_bounce_back_time <= 0
-        m_bounce_back_time = 0.1f;
+}   // playCrashSFX
-    }
-}   // crashed
 
 // -----------------------------------------------------------------------------
 /** Plays a beep sfx.

src/karts/kart.hpp

@@ -232,7 +232,7 @@ private:
     void          updateEngineSFX();
     void          updateNitro(float dt);
     float         getActualWheelForce();
-    void          crashed(const Material* m, AbstractKart *k);
+    void          playCrashSFX(const Material* m, AbstractKart *k);
     void          loadData(RaceManager::KartType type, bool animatedModel);
 
 public:

src/karts/kart_model.cpp

@@ -336,7 +336,7 @@ scene::ISceneNode* KartModel::attachModel(bool animated_models, bool always_anim
                                         irr_driver->getSceneManager()                    );
 
 
-        node = irr_driver->addAnimatedMesh(m_mesh);
+        node = irr_driver->addAnimatedMesh(m_mesh, "kartmesh");
         // as animated mesh are not cheap to render use frustum box culling
         if (irr_driver->isGLSL())
             node->setAutomaticCulling(scene::EAC_OFF);
@@ -407,17 +407,24 @@ scene::ISceneNode* KartModel::attachModel(bool animated_models, bool always_anim
         scene::IMesh* main_frame = m_mesh->getMesh(straight_frame);
         main_frame->setHardwareMappingHint(scene::EHM_STATIC);
 
-        node = irr_driver->addMesh(main_frame);
+        std::string debug_name;
+
+#ifdef DEBUG
+       debug_name = m_model_filename + " (kart-model)";
+#endif
+
+        node = irr_driver->addMesh(main_frame, debug_name);
+
 #ifdef DEBUG
-        std::string debug_name = m_model_filename+" (kart-model)";
         node->setName(debug_name.c_str());
 #endif
 
+
         // Attach the wheels
         for(unsigned int i=0; i<4; i++)
         {
             if(!m_wheel_model[i]) continue;
-            m_wheel_node[i] = irr_driver->addMesh(m_wheel_model[i], node);
+            m_wheel_node[i] = irr_driver->addMesh(m_wheel_model[i], "wheel", node);
             Vec3 wheel_min, wheel_max;
             MeshTools::minMax3D(m_wheel_model[i], &wheel_min, &wheel_max);
             m_wheel_graphics_radius[i] = 0.5f*(wheel_max.getY() - wheel_min.getY());
@@ -438,7 +445,7 @@ scene::ISceneNode* KartModel::attachModel(bool animated_models, bool always_anim
             obj.m_node = NULL;
             if(obj.m_model)
             {
-                obj.m_node = irr_driver->addAnimatedMesh(obj.m_model, node);
+                obj.m_node = irr_driver->addAnimatedMesh(obj.m_model, "speedweighted", node);
                 obj.m_node->grab();
 
                 obj.m_node->setFrameLoop(m_animation_frame[AF_SPEED_WEIGHTED_START], m_animation_frame[AF_SPEED_WEIGHTED_END]);
@@ -892,7 +899,7 @@ void KartModel::attachHat(){
             scene::IMesh *hat_mesh =
                 irr_driver->getAnimatedMesh(
                            file_manager->getAsset(FileManager::MODEL, m_hat_name));
-            m_hat_node = irr_driver->addMesh(hat_mesh);
+            m_hat_node = irr_driver->addMesh(hat_mesh, "hat");
             bone->addChild(m_hat_node);
             m_animated_node->setCurrentFrame((float)m_animation_frame[AF_STRAIGHT]);
             m_animated_node->OnAnimate(0);

src/main.cpp

@@ -1150,12 +1150,13 @@ void askForInternetPermission()
         };   // ConfirmServer
 
         new MessageDialog(_("SuperTuxKart may connect to a server "
-            "to download add-ons and notify you of updates. Would you "
+            "to download add-ons and notify you of updates. We also collect "
-            "like this feature to be enabled? (To change this setting "
+            "anonymous hardware statistics to help with the development of STK. "
+            "Would you like this feature to be enabled? (To change this setting "
             "at a later time, go to options, select tab "
             "'User Interface', and edit \"Allow STK to connect to the "
-            "Internet\")."),
+            "Internet\" and \"Allow STK to send anonymous HW statistics\")."),
-            MessageDialog::MESSAGE_DIALOG_CONFIRM,
+            MessageDialog::MESSAGE_DIALOG_YESNO,
             new ConfirmServer(), true);
     }
 
@@ -1302,6 +1303,8 @@ int main(int argc, char *argv[] )
             }
         }
 
+        // Note that on the very first run of STK internet status is set to
+        // "not asked", so the report will only be sent in the next run.
         if(UserConfigParams::m_internet_status==Online::RequestManager::IPERM_ALLOWED)
         {
             HardwareStats::reportHardwareStats();

src/modes/three_strikes_battle.cpp

@@ -144,13 +144,13 @@ void ThreeStrikesBattle::kartAdded(AbstractKart* kart, scene::ISceneNode* node)
 {
     float coord = -kart->getKartLength()*0.5f;
 
-    scene::IMeshSceneNode* tire_node = irr_driver->addMesh(m_tire, node);
+    scene::IMeshSceneNode* tire_node = irr_driver->addMesh(m_tire, "3strikestire", node);
     tire_node->setPosition(core::vector3df(-0.16f, 0.3f, coord - 0.25f));
     tire_node->setScale(core::vector3df(0.4f, 0.4f, 0.4f));
     tire_node->setRotation(core::vector3df(90.0f, 0.0f, 0.0f));
     tire_node->setName("tire1");
 
-    tire_node = irr_driver->addMesh(m_tire, node);
+    tire_node = irr_driver->addMesh(m_tire, "3strikestire", node);
     tire_node->setPosition(core::vector3df(0.16f, 0.3f, coord - 0.25f));
     tire_node->setScale(core::vector3df(0.4f, 0.4f, 0.4f));
     tire_node->setRotation(core::vector3df(90.0f, 0.0f, 0.0f));

src/online/online_player_profile.cpp

@@ -29,7 +29,6 @@
 #include "states_screens/online_profile_friends.hpp"
 #include "states_screens/user_screen.hpp"
 #include "states_screens/dialogs/change_password_dialog.hpp"
-#include "states_screens/dialogs/notification_dialog.hpp"
 #include "states_screens/dialogs/user_info_dialog.hpp"
 #include "utils/log.hpp"
 #include "utils/translation.hpp"

src/race/grand_prix_data.cpp

@@ -70,6 +70,7 @@ void GrandPrixData::createRandomGP(const unsigned int number_of_tracks,
     m_name     = "Random Grand Prix";
     m_editable = false;
     m_group    = GP_NONE;
+    m_reverse_type = use_reverse;
 
     if(new_tracks)
     {
@@ -155,6 +156,7 @@ void GrandPrixData::changeTrackNumber(const unsigned int number_of_tracks,
  */
 void GrandPrixData::changeReverse(const GrandPrixData::GPReverseType use_reverse)
 {
+    m_reverse_type = use_reverse;
     for (unsigned int i = 0; i < m_tracks.size(); i++)
     {
         if (use_reverse == GP_NO_REVERSE)

src/race/grand_prix_data.hpp

@@ -94,6 +94,9 @@ public:
         GP_DEFAULT_REVERSE = 3
     };   // GPReverseType
 
+private:
+    GPReverseType m_reverse_type;
+
 public:
 #if (defined(WIN32) || defined(_WIN32)) && !defined(__MINGW32__)
 #  pragma warning(disable:4290)
@@ -145,22 +148,25 @@ public:
     // ------------------------------------------------------------------------
     /** @return the (potentially translated) user-visible name of the Grand
      *  Prix (apply fribidi as needed) */
-    irr::core::stringw getName()     const { return _LTR(m_name.c_str()); }
+    irr::core::stringw getName()      const { return _LTR(m_name.c_str()); }
 
     // ------------------------------------------------------------------------
     /** @return the internal indentifier of the Grand Prix (not translated) */
-    const std::string& getId()       const { return m_id;                 }
+    const std::string& getId()        const { return m_id;                 }
 
     // ------------------------------------------------------------------------
     /** Returns true if this GP is a random GP. */
-    bool isRandomGP() const { return m_id=="random"; }
+    bool isRandomGP()                 const { return m_id=="random";       }
     // ------------------------------------------------------------------------
     /** Returns the filename of the grand prix xml file. */
-    const std::string& getFilename() const { return m_filename;           }
+    const std::string& getFilename()  const { return m_filename;           }
 
     // ------------------------------------------------------------------------
-    /** Returns the group. */
+    enum GPGroupType getGroup()       const { return m_group;              }
-    enum GPGroupType getGroup()      const { return m_group;              }
+
+    // ------------------------------------------------------------------------
+    enum GPReverseType getReverseType()
+                                      const { return m_reverse_type;       }
 };   // GrandPrixData
 
 #endif

src/race/race_manager.cpp

@@ -288,15 +288,42 @@ void RaceManager::computeRandomKartList()
 void RaceManager::startNew(bool from_overworld)
 {
     m_started_from_overworld = from_overworld;
+    m_saved_gp = NULL; // There will be checks for this being NULL done later
 
-    if(m_major_mode==MAJOR_MODE_GRAND_PRIX)
+    if (m_major_mode==MAJOR_MODE_GRAND_PRIX)
     {
         // GP: get tracks, laps and reverse info from grand prix
         m_tracks        = m_grand_prix.getTrackNames();
         m_num_laps      = m_grand_prix.getLaps();
         m_reverse_track = m_grand_prix.getReverse();
+
+        // We look if Player 1 has a saved version of this GP.
+        m_saved_gp = SavedGrandPrix::getSavedGP(
+                                     StateManager::get()
+                                     ->getActivePlayerProfile(0)
+                                     ->getUniqueID(),
+                                     m_grand_prix.getId(),
+                                     m_player_karts.size());
+
+        // Saved GP only in offline mode
+        if (m_continue_saved_gp && !NetworkWorld::getInstance<NetworkWorld>()->isRunning())
+        {
+            if (m_saved_gp == NULL)
+            {
+                Log::error("Race Manager", "Can not continue Grand Prix '%s'"
+                                           "because it could not exist",
+                                           m_grand_prix.getId().c_str());
+                m_continue_saved_gp = false; // simple and working
+            }
+            else
+            {
+                setNumKarts(m_saved_gp->getTotalKarts());
+                setupPlayerKartInfo();
+                m_grand_prix.changeReverse((GrandPrixData::GPReverseType)m_saved_gp->getReverseType());
+                m_reverse_track = m_grand_prix.getReverse();
+            }
+        }
     }
-    //assert(m_player_karts.size() > 0);
 
     // command line parameters: negative numbers=all karts
     if(m_num_karts < 0 ) m_num_karts = stk_config->m_max_karts;
@@ -318,8 +345,8 @@ void RaceManager::startNew(bool from_overworld)
         race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER
         ? -1
         : 0;
-    const unsigned int ai_kart_count = (unsigned int) m_ai_kart_list.size();
+    const unsigned int ai_kart_count = m_ai_kart_list.size();
-    for(unsigned int i=0; i<ai_kart_count; i++)
+    for(unsigned int i = 0; i < ai_kart_count; i++)
     {
         m_kart_status.push_back(KartStatus(m_ai_kart_list[i], i, -1, -1,
             init_gp_rank, KT_AI, UserConfigParams::m_ai_handicap ?
@@ -334,7 +361,7 @@ void RaceManager::startNew(bool from_overworld)
 
     // Then the players, which start behind the AI karts
     // -------------------------------------------------
-    for(unsigned int i=0; i<(unsigned int)m_player_karts.size(); i++)
+    for(unsigned int i = 0; i < m_player_karts.size(); i++)
     {
         KartType kt= m_player_karts[i].isNetworkPlayer() ? KT_NETWORK_PLAYER : KT_PLAYER;
         m_kart_status.push_back(KartStatus(m_player_karts[i].getKartName(), i,
@@ -351,34 +378,20 @@ void RaceManager::startNew(bool from_overworld)
     }
 
     m_track_number = 0;
-    if(m_major_mode==MAJOR_MODE_GRAND_PRIX &&
+    if (m_major_mode == MAJOR_MODE_GRAND_PRIX)
-        !NetworkWorld::getInstance<NetworkWorld>()->isRunning()) // offline mode only
     {
-        //We look if Player 1 has a saved version of this GP.
+        if (m_continue_saved_gp)
-        // =================================================
-        SavedGrandPrix* gp = SavedGrandPrix::getSavedGP( StateManager::get()
-                                                         ->getActivePlayerProfile(0)
-                                                         ->getUniqueID(),
-                                                         m_grand_prix.getId(),
-                                                         m_difficulty,
-                                                         m_num_karts,
-                                                         (int)m_player_karts.size());
-
-        // Start the race with the appropriate track
-        // =========================================
-        if(gp != NULL)
         {
-            if (m_continue_saved_gp)
+            m_track_number  = m_saved_gp->getNextTrack();
-            {
+            m_saved_gp->loadKarts(m_kart_status);
-                m_track_number = gp->getNextTrack();
+        }
-                gp->loadKarts(m_kart_status);
+        else if (m_saved_gp != NULL)
-            }
+        {
-            else
+            m_saved_gp->remove();
-            {
+            m_saved_gp = NULL;
-                gp->remove();
-            }
         }
     }
+
     startNextRace();
 }   // startNew
 
@@ -493,7 +506,6 @@ void RaceManager::startNextRace()
 }   // startNextRace
 
 //-----------------------------------------------------------------------------
-
 void RaceManager::next()
 {
     World::deleteWorld();
@@ -504,38 +516,18 @@ void RaceManager::next()
     {
         if(m_major_mode==MAJOR_MODE_GRAND_PRIX && !NetworkWorld::getInstance()->isRunning())
         {
-            //Saving GP state
+            // Saving GP state
-            //We look if Player 1 has already saved this GP.
+            // If Player 1 has already saved a GP, we adapt it
-            SavedGrandPrix* gp =
+            if(m_saved_gp != NULL)
-                SavedGrandPrix::getSavedGP(StateManager::get()
-                                           ->getActivePlayerProfile(0)
-                                           ->getUniqueID(),
-                                           m_grand_prix.getId(),
-                                           m_difficulty,
-                                           m_num_karts,
-                                           (int)m_player_karts.size());
-            if(gp != NULL)
             {
-                //if so addept it
+                m_saved_gp->setKarts(m_kart_status);
-                gp->setKarts(m_kart_status);
+                m_saved_gp->setNextTrack(m_track_number);
-                gp->setNextTrack(m_track_number);
+                user_config->saveConfig();
             }
             else
             {
-                //create a new entry
+                saveGP();
-                UserConfigParams::m_saved_grand_prix_list.push_back(
-                    new SavedGrandPrix(
-                        StateManager::get()->getActivePlayerProfile(0)
-                                           ->getUniqueID(),
-                        m_grand_prix.getId(),
-                        m_difficulty,
-                        (int)m_player_karts.size(),
-                        m_track_number,
-                        m_kart_status
-                    )
-                );
             }
-            user_config->saveConfig();
         }
         startNextRace();
     }
@@ -545,6 +537,24 @@ void RaceManager::next()
     }
 }   // next
 
+//-----------------------------------------------------------------------------
+void RaceManager::saveGP()
+{
+    UserConfigParams::m_saved_grand_prix_list.push_back(
+        new SavedGrandPrix(
+            StateManager::get()->getActivePlayerProfile(0)
+                               ->getUniqueID(),
+            m_grand_prix.getId(),
+            m_difficulty,
+            (int)m_player_karts.size(),
+            m_track_number,
+            m_grand_prix.getReverseType(),
+            m_kart_status
+        )
+    );
+    user_config->saveConfig();
+}
+
 //-----------------------------------------------------------------------------
 
 /** This class is only used in computeGPRanks, but the C++ standard
@@ -641,16 +651,8 @@ void RaceManager::exitRace(bool delete_world)
         PlayerManager::getCurrentPlayer()->grandPrixFinished();
         if(m_major_mode==MAJOR_MODE_GRAND_PRIX&& !NetworkWorld::getInstance()->isRunning())
         {
-            //Delete saved GP
+            if(m_saved_gp != NULL)
-            SavedGrandPrix* gp =
+                m_saved_gp->remove();
-                SavedGrandPrix::getSavedGP(StateManager::get()
-                                           ->getActivePlayerProfile(0)
-                                           ->getUniqueID(),
-                                           m_grand_prix.getId(),
-                                           m_difficulty,
-                                           m_num_karts,
-                                           (int)m_player_karts.size());
-            if(gp != NULL) gp->remove();
         }
         StateManager::get()->resetAndGoToScreen( MainMenuScreen::getInstance() );
 
@@ -728,6 +730,7 @@ void RaceManager::exitRace(bool delete_world)
 
     if (delete_world) World::deleteWorld();
 
+    m_saved_gp = NULL;
     m_track_number = 0;
 }   // exitRace
 
@@ -777,7 +780,6 @@ void RaceManager::startGP(const GrandPrixData &gp, bool from_overworld,
 {
     StateManager::get()->enterGameState();
     setGrandPrix(gp);
-    setCoinTarget( 0 ); // Might still be set from a previous challenge
     race_manager->setupPlayerKartInfo();
     m_continue_saved_gp = continue_saved_gp;
 

src/race/race_manager.hpp

@@ -36,6 +36,7 @@
 #include "utils/vec3.hpp"
 
 class AbstractKart;
+class SavedGrandPrix;
 class Track;
 
 static const std::string IDENT_STD      ("STANDARD"        );
@@ -329,6 +330,7 @@ private:
     std::vector<std::string>         m_ai_kart_list;
     int                              m_track_number;
     GrandPrixData                    m_grand_prix;
+    SavedGrandPrix*                  m_saved_gp;
     int                              m_num_karts;
     unsigned int                     m_num_finished_karts;
     unsigned int                     m_num_finished_players;
@@ -417,11 +419,13 @@ public:
       */
     void setDifficulty(Difficulty diff);
 
+    // ------------------------------------------------------------------------
+    void setCoinTarget(int num)   { m_coin_target = num;        }
     // ------------------------------------------------------------------------
     void setGrandPrix(const GrandPrixData &gp)
     {
         m_grand_prix = gp;
-        m_coin_target = 0;
+        setCoinTarget(0);
     }
     // ------------------------------------------------------------------------
     void setAIKartOverride(const std::string& kart)
@@ -460,8 +464,6 @@ public:
         m_ai_superpower = SUPERPOWER_NONE;
     }
     // ------------------------------------------------------------------------
-    void setCoinTarget(int num)   { m_coin_target = num;        }
-    // ------------------------------------------------------------------------
     void setTimeTarget(float num) { m_has_time_target = true;
                                     m_time_target = num;        }
     /** \} */
@@ -695,8 +697,11 @@ public:
       * \brief Higher-level method to start a GP without having to care about
       *  the exact startup sequence
       */
-    void  startGP(const GrandPrixData &gp, bool from_overworld,
+    void startGP(const GrandPrixData &gp, bool from_overworld,
-                  bool continue_saved_gp);
+                 bool continue_saved_gp);
+
+    /** Saves the current GP to the config */
+    void saveGP();
 
     /**
       * \brief Higher-level method to start a GP without having to care about

src/states_screens/dialogs/gp_info_dialog.cpp

@@ -203,8 +203,6 @@ void GPInfoDialog::addButtons()
                                                ->getActivePlayerProfile(0)
                                                ->getUniqueID(),
                                                m_gp.getId(),
-                                               race_manager->getDifficulty(),
-                                               race_manager->getNumberOfKarts(),
                                                race_manager->getNumLocalPlayers());
 
     okBtn->m_properties[PROP_ID] = "start";

src/states_screens/dialogs/message_dialog.cpp

@@ -95,6 +95,14 @@ void MessageDialog::doInit(MessageDialogType type,
         cancelbtn->setText(_("OK"));
         cancelbtn->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
     }
+    else if (type == MessageDialog::MESSAGE_DIALOG_YESNO)
+    {
+        ButtonWidget* yesbtn = getWidget<ButtonWidget>("confirm");
+
+        ButtonWidget* cancelbtn = getWidget<ButtonWidget>("cancel");
+        cancelbtn->setText(_("No"));
+
+    }
     else if (type == MessageDialog::MESSAGE_DIALOG_OK_CANCEL)
     {
         // In case of a OK_CANCEL dialog, change the text from 'Yes' to 'Ok'

src/states_screens/dialogs/message_dialog.hpp

@@ -62,7 +62,7 @@ public:
     };
 
     enum MessageDialogType { MESSAGE_DIALOG_OK, MESSAGE_DIALOG_CONFIRM,
-                             MESSAGE_DIALOG_OK_CANCEL                    };
+                             MESSAGE_DIALOG_OK_CANCEL, MESSAGE_DIALOG_YESNO };
     
 private:
     

src/states_screens/dialogs/notification_dialog.cpp

@@ -1,152 +0,0 @@
-//  SuperTuxKart - a fun racing game with go-kart
-//  Copyright (C) 2013 Glenn De Jonghe
-//
-//  This program 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 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 General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-
-#include "states_screens/dialogs/notification_dialog.hpp"
-
-#include <IGUIEnvironment.h>
-
-#include "config/player_manager.hpp"
-#include "guiengine/engine.hpp"
-#include "states_screens/state_manager.hpp"
-#include "states_screens/online_profile_achievements.hpp"
-#include "states_screens/online_profile_friends.hpp"
-#include "utils/translation.hpp"
-
-
-using namespace GUIEngine;
-using namespace irr;
-using namespace irr::gui;
-using namespace Online;
-
-// -----------------------------------------------------------------------------
-
-NotificationDialog::NotificationDialog(Type type, const core::stringw &info)
-        : ModalDialog(0.8f,0.5f)
-{
-    m_info = info;
-    m_type = type;
-}
-
-void NotificationDialog::load()
-{
-    loadFromFile("online/notification_dialog.stkgui");
-}
-
-void NotificationDialog::beforeAddingWidgets()
-{
-    m_self_destroy = false;
-    m_view = false;
-    m_info_widget = getWidget<LabelWidget>("info");
-    assert(m_info_widget != NULL);
-    m_info_widget->setText(m_info, false);
-    m_options_widget = getWidget<RibbonWidget>("options");
-    assert(m_options_widget != NULL);
-    m_view_widget = getWidget<IconButtonWidget>("view");
-    assert(m_view_widget != NULL);
-    if(m_type == T_Friends)
-    {
-        m_view_widget->setText(_("View Friends"));
-    }
-    else if (m_type == T_Achievements)
-    {
-        m_view_widget->setText(_("View Achievements"));
-    }
-    m_cancel_widget = getWidget<IconButtonWidget>("cancel");
-    assert(m_cancel_widget != NULL);
-    m_options_widget->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
-}
-
-
-
-// -----------------------------------------------------------------------------
-NotificationDialog::~NotificationDialog()
-{
-}
-
-// -----------------------------------------------------------------------------
-GUIEngine::EventPropagation NotificationDialog::processEvent(const std::string& eventSource)
-{
-
-    if (eventSource == m_options_widget->m_properties[PROP_ID])
-    {
-        const std::string& selection = m_options_widget->getSelectionIDString(PLAYER_ID_GAME_MASTER);
-        if (selection == m_cancel_widget->m_properties[PROP_ID])
-        {
-            m_self_destroy = true;
-            return GUIEngine::EVENT_BLOCK;
-        }
-        else if(selection == m_view_widget->m_properties[PROP_ID])
-        {
-            m_view = true;
-            return GUIEngine::EVENT_BLOCK;
-        }
-    }
-    return GUIEngine::EVENT_LET;
-}
-
-// -----------------------------------------------------------------------------
-
-void NotificationDialog::onEnterPressedInternal()
-{
-
-    //If enter was pressed while none of the buttons was focused interpret as close
-    const int playerID = PLAYER_ID_GAME_MASTER;
-    if (GUIEngine::isFocusedForPlayer(m_options_widget, playerID))
-        return;
-    m_self_destroy = true;
-}
-
-// -----------------------------------------------------------------------------
-
-bool NotificationDialog::onEscapePressed()
-{
-    if (m_cancel_widget->isActivated())
-        m_self_destroy = true;
-    return false;
-}
-
-// -----------------------------------------------------------------------------
-
-void NotificationDialog::onUpdate(float dt)
-{
-    //If we want to open the registration dialog, we need to close this one first
-    if (m_view) m_self_destroy = true;
-
-    // It's unsafe to delete from inside the event handler so we do it here
-    if (m_self_destroy)
-    {
-        // Since dismiss deletes this object, store the instance values which
-        // we still need
-        bool view = m_view;
-        NotificationDialog::Type type = m_type;
-        ModalDialog::dismiss();
-        if (view)
-        {
-            if(type == T_Friends)
-            {
-                ProfileManager::get()->setVisiting(PlayerManager::getCurrentOnlineId());
-                OnlineProfileFriends::getInstance()->push();
-            }
-            else if (type == T_Achievements)
-            {
-                ProfileManager::get()->setVisiting(PlayerManager::getCurrentOnlineId());
-                OnlineProfileAchievements::getInstance()->push();
-            }
-        }
-        return;
-    }
-}

src/states_screens/dialogs/notification_dialog.hpp

@@ -1,68 +0,0 @@
-//  SuperTuxKart - a fun racing game with go-kart
-//  Copyright (C) 2013 Glenn De Jonghe
-//
-//  This program 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 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 General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-
-
-#ifndef HEADER_NOTIFICATION_DIALOG_HPP
-#define HEADER_NOTIFICATION_DIALOG_HPP
-
-#include "guiengine/modaldialog.hpp"
-#include "guiengine/widgets.hpp"
-#include "utils/types.hpp"
-
-#include <irrString.h>
-
-
-/**
- * \brief Dialog that allows a user to sign in
- * \ingroup states_screens
- */
-class NotificationDialog : public GUIEngine::ModalDialog
-{
-public:
-    enum Type
-    {
-        T_Friends = 1,
-        T_Achievements = 2
-    };
-
-private:
-    bool m_self_destroy;
-    bool m_view;
-    Type m_type;
-    irr::core::stringw m_info;
-
-    GUIEngine::LabelWidget * m_info_widget;
-
-    GUIEngine::RibbonWidget * m_options_widget;
-    GUIEngine::IconButtonWidget * m_view_widget;
-    GUIEngine::IconButtonWidget * m_cancel_widget;
-
-public:
-    NotificationDialog(Type type, const core::stringw &info);
-    ~NotificationDialog();
-
-    virtual void beforeAddingWidgets();
-    virtual void load();
-
-    void onEnterPressedInternal();
-    GUIEngine::EventPropagation processEvent(const std::string& eventSource);
-
-    virtual bool onEscapePressed();
-    virtual void onUpdate(float dt);
-};
-
-#endif

src/states_screens/feature_unlocked.cpp

@@ -286,7 +286,8 @@ void FeatureUnlockedCutScene::init()
     {
         if (m_unlocked_stuff[n].m_unlock_model.size() > 0)
         {
-            m_unlocked_stuff[n].m_root_gift_node = irr_driver->addMesh( irr_driver->getMesh(m_unlocked_stuff[n].m_unlock_model) );
+            m_unlocked_stuff[n].m_root_gift_node = irr_driver->addMesh(
+                irr_driver->getMesh(m_unlocked_stuff[n].m_unlock_model), "unlocked_model");
             m_unlocked_stuff[n].m_scale = 0.7f;
             //m_unlocked_stuff[n].m_root_gift_node->setScale(core::vector3df(0.2f, 0.2f, 0.2f));
         }
@@ -336,13 +337,13 @@ void FeatureUnlockedCutScene::init()
                                                    m_unlocked_stuff[n].m_w,
                                                    m_unlocked_stuff[n].m_h);
             m_unlocked_stuff[n].m_root_gift_node = irr_driver->getSceneManager()->addEmptySceneNode();
-            m_unlocked_stuff[n].m_side_1 = irr_driver->addMesh(mesh, m_unlocked_stuff[n].m_root_gift_node);
+            m_unlocked_stuff[n].m_side_1 = irr_driver->addMesh(mesh, "unlocked_picture", m_unlocked_stuff[n].m_root_gift_node);
             //mesh->drop();
 
             mesh = irr_driver->createTexturedQuadMesh(&m,
                 m_unlocked_stuff[n].m_w,
                 m_unlocked_stuff[n].m_h);
-            m_unlocked_stuff[n].m_side_2 = irr_driver->addMesh(mesh, m_unlocked_stuff[n].m_root_gift_node);
+            m_unlocked_stuff[n].m_side_2 = irr_driver->addMesh(mesh, "unlocked_picture",  m_unlocked_stuff[n].m_root_gift_node);
             m_unlocked_stuff[n].m_side_2->setRotation(core::vector3df(0.0f, 180.0f, 0.0f));
             //mesh->drop();
 #ifdef DEBUG

src/states_screens/gp_info_screen.cpp

@@ -81,7 +81,7 @@ void GPInfoScreen::loadedFromFile()
     // Only init the number of tracks here, this way the previously selected
     // number of tracks will be the default.
     m_num_tracks_spinner->setValue(1);
-    
+
     m_ai_kart_spinner = getWidget<SpinnerWidget>("ai-spinner");
 }   // loadedFromFile
 
@@ -97,14 +97,14 @@ void GPInfoScreen::setGP(const std::string &gp_ident)
     {
         // Doesn't matter what kind of GP we create, it just gets the
         // right id ("random").
-        m_gp.createRandomGP(1, "standard", 
+        m_gp.createRandomGP(1, "standard",
                             m_reverse_spinner ? getReverse()
                                               : GrandPrixData::GP_NO_REVERSE);
     }
 }   // setGP
 
 // ----------------------------------------------------------------------------
-/** Converts the currently selected reverse status into a value of type 
+/** Converts the currently selected reverse status into a value of type
 *  GPReverseType .
 */
 GrandPrixData::GPReverseType GPInfoScreen::getReverse() const
@@ -130,8 +130,6 @@ void GPInfoScreen::beforeAddingWidget()
         SavedGrandPrix* saved_gp = SavedGrandPrix::getSavedGP(
             StateManager::get()->getActivePlayerProfile(0)->getUniqueID(),
             m_gp.getId(),
-            race_manager->getDifficulty(),
-            race_manager->getNumberOfKarts(),
             race_manager->getNumLocalPlayers());
 
         RibbonWidget* ribbonButtons = getWidget<RibbonWidget>("buttons");
@@ -194,10 +192,10 @@ void GPInfoScreen::init()
         else
             m_group_name = stringc(m_group_spinner->getStringValue().c_str()).c_str();
 
-        // If there are more tracks selected atm as in the group (which can 
+        // If there are more tracks selected atm as in the group (which can
         // happen if the group has been changed since last time this screen
         // was shown), adjust it:
-        int max_num_tracks = m_group_name=="all" 
+        int max_num_tracks = m_group_name=="all"
                            ? track_manager->getNumberOfRaceTracks()
                            : (int)track_manager->getTracksInGroup(m_group_name).size();
         m_num_tracks_spinner->setMax(max_num_tracks);
@@ -207,7 +205,7 @@ void GPInfoScreen::init()
         }
 
         // Now create the random GP:
-        m_gp.createRandomGP(m_num_tracks_spinner->getValue(), 
+        m_gp.createRandomGP(m_num_tracks_spinner->getValue(),
                             m_group_name, getReverse(), true);
     }
     else
@@ -215,7 +213,7 @@ void GPInfoScreen::init()
         getWidget<LabelWidget>("name")->setText(m_gp.getName(), false);
         m_gp.checkConsistency();
     }
-    
+
     // Number of AIs
     // -------------
     const bool has_AI = race_manager->hasAI();
@@ -288,7 +286,7 @@ void GPInfoScreen::addScreenshot()
     m_screenshot_widget->m_h = screenshot_div->m_h;
 
 
-    // Temporary icon, will replace it just after 
+    // Temporary icon, will replace it just after
     // (but it will be shown if the given icon is not found)
     m_screenshot_widget->m_properties[PROP_ICON] = "gui/main_help.png";
     m_screenshot_widget->add();
@@ -336,7 +334,7 @@ void GPInfoScreen::eventCallback(Widget *, const std::string &name,
         // the current track. The current value in the Number-of-tracks-spinner
         // has to be updated, since otherwise the displayed (and used) value
         // can be bigger than the maximum. (Might be a TODO to fix this)
-        int max_num_tracks = m_group_name=="all" 
+        int max_num_tracks = m_group_name=="all"
                            ? track_manager->getNumberOfRaceTracks()
                            : (int)track_manager->getTracksInGroup(m_group_name).size();
         m_num_tracks_spinner->setMax(max_num_tracks);
@@ -344,7 +342,7 @@ void GPInfoScreen::eventCallback(Widget *, const std::string &name,
             m_num_tracks_spinner->setValue(max_num_tracks);
         // Create a new (i.e. with new tracks) random gp, since the old
         // tracks might not all belong to the newly selected group.
-        
+
         m_gp.createRandomGP(m_num_tracks_spinner->getValue(), m_group_name,
                             getReverse(),  /*new_tracks*/true);
         addTracks();
@@ -359,11 +357,6 @@ void GPInfoScreen::eventCallback(Widget *, const std::string &name,
         const int num_ai = m_ai_kart_spinner->getValue();
         race_manager->setNumKarts( race_manager->getNumLocalPlayers() + num_ai );
         UserConfigParams::m_num_karts = race_manager->getNumLocalPlayers() + num_ai;
-        
-        //Redraw scene because available buttons depend on current settings
-        getWidget<RibbonWidget>("buttons")->setSelection(0, PLAYER_ID_GAME_MASTER);
-        reshowCurrentScreen();
-        m_ai_kart_spinner->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
     }
     else if(name=="back")
     {

src/states_screens/main_menu_screen.cpp

@@ -97,6 +97,9 @@ void MainMenuScreen::init()
 {
     Screen::init();
 
+    m_user_id = getWidget<ButtonWidget>("user-id");
+    assert(m_user_id);
+
     // reset in case we're coming back from a race
     StateManager::get()->resetActivePlayers();
     input_manager->getDeviceList()->setAssignMode(NO_ASSIGN);
@@ -155,9 +158,11 @@ void MainMenuScreen::init()
 void MainMenuScreen::onUpdate(float delta)
 
 {
+    PlayerProfile *player = PlayerManager::getCurrentPlayer();
     if(PlayerManager::getCurrentOnlineState() == PlayerProfile::OS_GUEST  ||
        PlayerManager::getCurrentOnlineState() == PlayerProfile::OS_SIGNED_IN)
     {
+        m_user_id->setText(player->getLastOnlineName() + "@stk");
         m_online->setActivated();
         m_online->setLabel( _("Online"));
     }
@@ -165,9 +170,14 @@ void MainMenuScreen::onUpdate(float delta)
     {
         m_online->setActivated();
         m_online->setLabel( _("Login" ));
+        m_user_id->setText(player->getName());
     }
-    else // now must be either logging in or logging out
+    else 
+    {
+        // now must be either logging in or logging out
         m_online->setDeactivated();
+        m_user_id->setText(player->getName());
+    }
 
     m_online->setLabel(PlayerManager::getCurrentOnlineId() ? _("Online")
                                                            : _("Login" )  );
@@ -210,6 +220,12 @@ void MainMenuScreen::onUpdate(float delta)
 void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
                                    const int playerID)
 {
+    if(name=="user-id")
+    {
+        UserScreen::getInstance()->push();
+        return;
+    }
+
     // most interesting stuff is in the ribbons, so start there
     RibbonWidget* ribbon = dynamic_cast<RibbonWidget*>(widget);
 
@@ -446,7 +462,6 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
             //OnlineScreen::getInstance()->push();
             ProfileManager::get()->setVisiting(PlayerManager::getCurrentOnlineId());
             OnlineProfileAchievements::getInstance()->push();
-
         }
         else
         {

src/states_screens/main_menu_screen.hpp

@@ -20,8 +20,8 @@
 
 #include "guiengine/screen.hpp"
 
-namespace GUIEngine { class Widget; class ListWidget;
+namespace GUIEngine { class Widget;       class ListWidget; 
-                      class IconButtonWidget;         }
+                      class ButtonWidget; class IconButtonWidget; }
 
 /**
   * \brief Handles the main menu
@@ -35,6 +35,9 @@ private:
     /** Keep the widget to avoid looking it up every frame. */
     GUIEngine::IconButtonWidget* m_online;
 
+    /** Keep the widget to to the user name. */
+    GUIEngine::ButtonWidget *m_user_id;
+
     MainMenuScreen();
 
 public:

src/states_screens/options_screen_audio.cpp

@@ -163,7 +163,7 @@ void OptionsScreenAudio::eventCallback(Widget* widget, const std::string& name,
         CheckBoxWidget* w = dynamic_cast<CheckBoxWidget*>(widget);
 
         UserConfigParams::m_sfx = w->getState();
-        SFXManager::get()->soundToggled(UserConfigParams::m_sfx);
+        SFXManager::get()->toggleSound(UserConfigParams::m_sfx);
 
         if (UserConfigParams::m_sfx)
         {

src/states_screens/options_screen_ui.cpp

@@ -21,12 +21,14 @@
 #include "audio/music_manager.hpp"
 #include "audio/sfx_manager.hpp"
 #include "audio/sfx_base.hpp"
+#include "config/hardware_stats.hpp"
 #include "config/user_config.hpp"
 #include "guiengine/scalable_font.hpp"
 #include "guiengine/screen.hpp"
 #include "guiengine/widgets/button_widget.hpp"
 #include "guiengine/widgets/check_box_widget.hpp"
 #include "guiengine/widgets/dynamic_ribbon_widget.hpp"
+#include "guiengine/widgets/label_widget.hpp"
 #include "guiengine/widgets/list_widget.hpp"
 #include "guiengine/widgets/spinner_widget.hpp"
 #include "guiengine/widget.hpp"
@@ -130,6 +132,23 @@ void OptionsScreenUI::init()
     assert( news != NULL );
     news->setState( UserConfigParams::m_internet_status
                                      ==RequestManager::IPERM_ALLOWED );
+    CheckBoxWidget* stats = getWidget<CheckBoxWidget>("enable-hw-report");
+    assert( stats != NULL );
+    LabelWidget *stats_label = getWidget<LabelWidget>("label-hw-report");
+    assert( stats_label );
+            stats->setState(UserConfigParams::m_hw_report_enable);
+
+    if(news->getState())
+    {
+        stats_label->setVisible(true);
+        stats->setVisible(true);
+        stats->setState(UserConfigParams::m_hw_report_enable);
+    }
+    else
+    {
+        stats_label->setVisible(false);
+        stats->setVisible(false);
+    }
     CheckBoxWidget* difficulty = getWidget<CheckBoxWidget>("perPlayerDifficulty");
     assert( difficulty != NULL );
     difficulty->setState( UserConfigParams::m_per_player_difficulty );
@@ -257,8 +276,28 @@ void OptionsScreenUI::eventCallback(Widget* widget, const std::string& name, con
         // If internet gets enabled, re-initialise the addon manager (which
         // happens in a separate thread) so that news.xml etc can be
         // downloaded if necessary.
+        CheckBoxWidget *stats = getWidget<CheckBoxWidget>("enable-hw-report");
+        LabelWidget *stats_label = getWidget<LabelWidget>("label-hw-report");
         if(internet->getState())
+        {
             NewsManager::get()->init(false);
+            stats->setVisible(true);
+            stats_label->setVisible(true);
+            stats->setState(UserConfigParams::m_hw_report_enable);
+        }
+        else
+        {
+            stats->setVisible(false);
+            stats_label->setVisible(false);
+        }
+
+    }
+    else if (name=="enable-hw-report")
+    {
+        CheckBoxWidget* stats = getWidget<CheckBoxWidget>("enable-hw-report");
+        UserConfigParams::m_hw_report_enable = stats->getState();
+        if(stats->getState())
+            HardwareStats::reportHardwareStats();
     }
     else if (name=="show-login")
     {

src/states_screens/race_result_gui.cpp

@@ -393,6 +393,7 @@ void RaceResultGUI::eventCallback(GUIEngine::Widget* widget,
 
 void RaceResultGUI::onConfirm()
 {
+    race_manager->saveGP(); // Save the aborted GP
     GUIEngine::ModalDialog::dismiss();
     cleanupGPProgress();
     StateManager::get()->popMenu();

src/tracks/check_line.cpp

@@ -99,7 +99,7 @@ CheckLine::CheckLine(const XMLNode &node,  unsigned int index)
         }
         buffer->recalculateBoundingBox();
         mesh->setBoundingBox(buffer->getBoundingBox());
-        m_debug_node = irr_driver->addMesh(mesh);
+        m_debug_node = irr_driver->addMesh(mesh, "checkdebug");
         mesh->drop();
     }
     else

src/tracks/model_definition_loader.cpp

@@ -89,7 +89,7 @@ LODNode* ModelDefinitionLoader::instanciateAsLOD(const XMLNode* node, scene::ISc
             //cache.push_back(a_mesh);
             irr_driver->grabAllTextures(a_mesh);
             m_track->addCachedMesh(a_mesh);
-            scene::IMeshSceneNode* scene_node = irr_driver->addMesh(a_mesh);
+            scene::IMeshSceneNode* scene_node = irr_driver->addMesh(a_mesh, group[m].m_model_file);
 
             m_track->handleAnimatedTextures( scene_node, *group[m].m_xml );
 
@@ -135,4 +135,4 @@ void ModelDefinitionLoader::cleanLibraryNodesAfterLoad()
         file_manager->popTextureSearchPath();
         file_manager->popModelSearchPath();
     }
-}
+}

src/tracks/quad_graph.cpp

@@ -551,7 +551,7 @@ void QuadGraph::createDebugMesh()
         c.setBlue((i%2) ? 0 : 255);
         v[i].Color = c;
     }
-    m_node = irr_driver->addMesh(m_mesh);
+    m_node = irr_driver->addMesh(m_mesh, "quad_graph_debug");
 #ifdef DEBUG
     m_node->setName("track-debug-mesh");
 #endif
@@ -1006,7 +1006,7 @@ void QuadGraph::makeMiniMap(const core::dimension2du &dimension,
                /*track_color*/    &fill_color,
                /*lap line color*/  &red                       );
 
-    m_node = irr_driver->addMesh(m_mesh);
+    m_node = irr_driver->addMesh(m_mesh, "mini_map");
 #ifdef DEBUG
     m_node->setName("minimap-mesh");
 #endif
@@ -1104,6 +1104,13 @@ void QuadGraph::makeMiniMap(const core::dimension2du &dimension,
     *newRttMinimap = frame_buffer;
     World::getWorld()->setClearbackBufferColor(oldClearColor);
     World::getWorld()->forceFogDisabled(false);
+
+    irr_driver->getSceneManager()->clear();
+    VAOManager::kill();
+    irr_driver->clearGlowingNodes();
+    irr_driver->clearLights();
+    irr_driver->clearForcedBloom();
+    irr_driver->clearBackgroundNodes();
 }   // makeMiniMap
 
 //-----------------------------------------------------------------------------

src/tracks/track.cpp

@@ -999,7 +999,7 @@ bool Track::loadMainTrack(const XMLNode &root)
 
     // The merged mesh is grabbed by the octtree, so we don't need
     // to keep a reference to it.
-    scene::ISceneNode *scene_node = irr_driver->addMesh(tangent_mesh);
+    scene::ISceneNode *scene_node = irr_driver->addMesh(tangent_mesh, "track_main");
     //scene::IMeshSceneNode *scene_node = irr_driver->addOctTree(merged_mesh);
     // We should drop the merged mesh (since it's now referred to in the
     // scene node), but then we need to grab it since it's in the
@@ -1213,7 +1213,7 @@ bool Track::loadMainTrack(const XMLNode &root)
 
             // create a node out of this mesh just for bullet; delete it after, normal maps are special
             // and require tangent meshes
-            scene_node = irr_driver->addMesh(original_mesh);
+            scene_node = irr_driver->addMesh(original_mesh, "original_mesh");
 
             scene_node->setPosition(xyz);
             scene_node->setRotation(hpr);
@@ -1228,7 +1228,7 @@ bool Track::loadMainTrack(const XMLNode &root)
             irr_driver->grabAllTextures(mesh);
 
             m_all_cached_meshes.push_back(mesh);
-            scene_node = irr_driver->addMesh(mesh);
+            scene_node = irr_driver->addMesh(mesh, "original_mesh_with_tangents");
             scene_node->setPosition(xyz);
             scene_node->setRotation(hpr);
             scene_node->setScale(scale);
@@ -1276,7 +1276,7 @@ bool Track::loadMainTrack(const XMLNode &root)
             m_all_cached_meshes.push_back(a_mesh);
             irr_driver->grabAllTextures(a_mesh);
             a_mesh->grab();
-            scene_node = irr_driver->addMesh(a_mesh);
+            scene_node = irr_driver->addMesh(a_mesh, model_name);
             scene_node->setPosition(xyz);
             scene_node->setRotation(hpr);
             scene_node->setScale(scale);
@@ -1532,7 +1532,7 @@ void Track::createWater(const XMLNode &node)
     }
     else
     {*/
-        scene_node = irr_driver->addMesh(mesh);
+        scene_node = irr_driver->addMesh(mesh, "water");
     //}
 
     if(!mesh || !scene_node)

src/tracks/track_object_presentation.cpp

@@ -370,7 +370,7 @@ void TrackObjectPresentationMesh::init(const XMLNode* xml_node, scene::ISceneNod
     else if (animated)
     {
         scene::IAnimatedMeshSceneNode *node =
-            irr_driver->addAnimatedMesh((scene::IAnimatedMesh*)m_mesh, parent);
+            irr_driver->addAnimatedMesh((scene::IAnimatedMesh*)m_mesh, m_model_file, parent);
         m_node = node;
 
         m_frame_start = node->getStartFrame();
@@ -387,7 +387,7 @@ void TrackObjectPresentationMesh::init(const XMLNode* xml_node, scene::ISceneNod
         if (xml_node)
             xml_node->get("displacing", &displacing);
 
-        m_node = irr_driver->addMesh(m_mesh, parent);
+        m_node = irr_driver->addMesh(m_mesh, m_model_file, parent);
 
         STKMeshSceneNode* stkmesh = dynamic_cast<STKMeshSceneNode*>(m_node);
         if (displacing && stkmesh != NULL)
@@ -482,7 +482,8 @@ TrackObjectPresentationSound::TrackObjectPresentationSound(const XMLNode& xml_no
     xml_node.get("max_dist", &max_dist );
 
     // first try track dir, then global dir
-    std::string soundfile = file_manager->getAsset(FileManager::MODEL,sound);
+    std::string soundfile = World::getWorld()->getTrack()->getTrackFile(sound);
+    //std::string soundfile = file_manager->getAsset(FileManager::MODEL,sound);
     if (!file_manager->fileExists(soundfile))
     {
         soundfile = file_manager->getAsset(FileManager::SFX, sound);

src/utils/tuple.hpp

@@ -81,7 +81,7 @@ namespace STK {
     template<typename... T>
     struct TupleSize
     {
-        int value;
+        const int value;
         TupleSize()
         {
             value = sizeof...(T);

tools/ibl.py

@@ -0,0 +1,92 @@
+import Image as img
+import numpy as np
+import pylab as pl
+
+n = 3
+GridI, GridJ = np.meshgrid(np.linspace(-1, 1, n), np.linspace(-1, 1, n))
+img = np.ones((n,n))
+
+# constant factor of Ylm
+c00 = 0.282095
+c1minus1 = 0.488603
+c10 = 0.488603
+c11 = 0.488603
+c2minus2 = 1.092548
+c2minus1 = 1.092548
+c21 = 1.092548
+c20 = 0.315392
+c22 = 0.546274
+
+def computeYmlOnGrid(Xgrid, Ygrid, Zgrid):
+    "compute Yml from Y00 to Y22 on Xgrid/Ygrid/Zgrid"
+    norm = np.sqrt(Xgrid * Xgrid + Ygrid * Ygrid + Zgrid * Zgrid)
+    Xg = Xgrid / norm
+    Yg = Ygrid / norm
+    Zg = Zgrid / norm
+    Y00 = c00
+    Y1minus1 = c1minus1 * Yg
+    Y10 = c10 * Zg
+    Y11 = c11 * Xg
+    Y2minus2 = c2minus2 * Xg * Yg
+    Y2minus1 = c2minus1 * Yg * Zg
+    Y21= c21 * Xg * Zg
+    Y20 = c20 * (3 * Zg * Zg - 1)
+    Y22 = c22 * (Xg * Xg - Yg * Yg)
+    return (Y00, Y1minus1, Y10, Y11, Y2minus2, Y2minus1, Y20, Y21, Y22)
+    
+# From http://www.rorydriscoll.com/2012/01/15/cubemap-texel-solid-angle/
+def areaToPoint(x, y):
+    return np.arctan2(x * y, np.sqrt(x * x + y * y + 1))
+    
+def getSolidAngleGrid(Xgrid, Ygrid):
+    "Compute solid angles using Xgrid/Ygrid/Zgrid texel position"
+    (step, _) = np.shape(Xgrid)
+    x0 = Xgrid - (1. / step)
+    x1 = Xgrid + (1. / step)
+    y0 = Ygrid - (1. / step)
+    y1 = Ygrid + (1. / step)
+    return areaToPoint(x0,y0) - areaToPoint(x1, y0) - areaToPoint(x0, y1) + areaToPoint(x1, y1)
+
+
+def computeCoefficients():
+    "Compute coefficient SH00 to SH22 for monochromatic img"
+    FaceGrid = [(np.ones((n,n)), -GridI, -GridJ), #GL_TEXTURE_CUBE_MAP_POSITIVE_X
+        (-1 * np.ones((n,n)), -GridI, GridJ), #GL_TEXTURE_CUBE_MAP_NEGATIVE_X
+        (GridJ, np.ones((n,n)), GridI), #GL_TEXTURE_CUBE_MAP_POSITIVE_Y
+        (GridJ, -1 * np.ones((n,n)), -GridI), #GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
+        (GridJ, GridI, np.ones((n,n))), #GL_TEXTURE_CUBE_MAP_POSITIVE_Z
+        (GridJ, -GridI, -1 * np.ones((n,n)))] #GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
+    incomingIrradiance =  getSolidAngleGrid(GridI, GridJ)
+    SH00 = 0
+    SH1minus1 = 0
+    SH10 = 0
+    SH11 = 0
+    SH2minus2 = 0
+    SH2minus1 = 0
+    SH20 = 0
+    SH21 = 0
+    SH22 = 0
+    for (Xgrid, Ygrid, Zgrid) in FaceGrid:
+        (Y00, Y1minus1, Y10, Y11, Y2minus2, Y2minus1, Y20, Y21, Y22) = computeYmlOnGrid(Xgrid, Ygrid, Zgrid)
+        SH00 += np.sum(Y00 * incomingIrradiance * img)
+        SH1minus1 += np.sum(Y1minus1 * incomingIrradiance * img)
+        SH10 += np.sum(Y10 * incomingIrradiance * img)
+        SH11 += np.sum(Y11 * incomingIrradiance * img)
+        SH2minus2 += np.sum(Y2minus2 * incomingIrradiance * img)
+        SH2minus1 += np.sum(Y2minus1 * incomingIrradiance * img)
+        SH20 += np.sum(Y20 * incomingIrradiance * img)
+        SH21 += np.sum(Y21 * incomingIrradiance * img)
+        SH22 += np.sum(Y22 * incomingIrradiance * img)
+    return (SH00, SH1minus1, SH10, SH2minus2, SH2minus1, SH20, SH21, SH22)
+
+print(computeCoefficients())
+
+#res = []
+#for (Xd, Yd, Zd) in FaceGrid:
+#    res.append(computeYmlOnGrid(Xd, Yd, Zd))
+
+
+#I = img.open("C:/Users/vljn_000/Documents/GitHub/stk-assets/textures/ants.png")
+#m = np.array(I)
+#print(type(m))
+#pl.imshow(m)