Merge branch 'dev' of https://github.com/adiblol/colobot into dev

Conflicts:
	src/ui/slider.cpp

3 files changed, 73 insertions, 150 deletions

diff --git a/src/graphics/engine/engine.cpp b/src/graphics/engine/engine.cpp
index af209bd..bd5f60f 100644
--- a/src/graphics/engine/engine.cpp
+++ b/src/graphics/engine/engine.cpp
@@ -139,7 +139,7 @@ Gfx::CEngine::CEngine(CInstanceManager *iMan, CApplication *app)
     m_backgroundCloudUp   = Gfx::Color();
     m_backgroundCloudDown = Gfx::Color();
     m_backgroundFull = false;
-    m_backgroundQuarter = false;
+    m_backgroundScale = Math::Point(1.0f, 1.0f);
     m_overFront = true;
     m_overColor = Gfx::Color();
     m_overMode  = ENG_RSTATE_TCOLOR_BLACK;
@@ -330,24 +330,6 @@ bool Gfx::CEngine::ProcessEvent(const Event &event)
             int index = static_cast<int>(m_mouseType);
             m_mouseType = static_cast<Gfx::EngineMouseType>( (index + 1) % Gfx::ENG_MOUSE_COUNT );
         }
-        else if (event.key.key == KEY(F3))
-        {
-            bool bq = !m_backgroundQuarter;
-            SetBackground(bq ? "geneda.png" : "", Gfx::Color(), Gfx::Color(), Gfx::Color(), Gfx::Color(), true, bq);
-        }
-        else if (event.key.key == KEY(F4))
-        {
-            m_skyMode = !m_skyMode;
-            if (! m_skyMode)
-            {
-                m_backgroundColorDown = Gfx::Color(0.2f, 0.2f, 0.2f);
-                m_backgroundColorUp = Gfx::Color(0.8f, 0.8f, 0.8f);
-            }
-            else
-            {
-                m_backgroundColorDown = m_backgroundColorUp = Gfx::Color(0.0f, 0.0f, 0.0f);
-            }
-        }
     }
 
     // By default, pass on all events
@@ -2148,26 +2130,10 @@ bool Gfx::CEngine::LoadAllTextures()
     LoadTexture("effect02.png");
     LoadTexture("map.png");
 
-    if (m_backgroundQuarter)  // image into 4 pieces?
-    {
-        if (! m_backgroundName.empty())
-        {
-            for (int i = 0; i < 4; i++)
-                m_backgroundQuarterTexs[i] = LoadTexture(m_backgroundQuarterNames[i]);
-        }
-        else
-        {
-            for (int i = 0; i < 4; i++)
-                m_backgroundQuarterTexs[i].SetInvalid();
-        }
-    }
+    if (! m_backgroundName.empty())
+        m_backgroundTex = LoadTexture(m_backgroundName);
     else
-    {
-        if (! m_backgroundName.empty())
-            m_backgroundFullTex = LoadTexture(m_backgroundName);
-        else
-            m_backgroundFullTex.SetInvalid();
-    }
+        m_backgroundTex.SetInvalid();
 
     if (! m_foregroundName.empty())
         m_foregroundTex = LoadTexture(m_foregroundName);
@@ -2446,29 +2412,14 @@ float Gfx::CEngine::GetFogStart(int rank)
     return m_fogStart[rank];
 }
 
-std::string QuarterName(const std::string& name, int quarter)
-{
-    size_t pos = name.find('.');
-    if (pos == std::string::npos)
-        return name;
-
-    return name.substr(0, pos) + std::string(1, static_cast<char>('a' + quarter)) + name.substr(pos);
-}
-
 void Gfx::CEngine::SetBackground(const std::string& name, Gfx::Color up, Gfx::Color down,
                                  Gfx::Color cloudUp, Gfx::Color cloudDown,
-                                 bool full, bool quarter)
+                                 bool full, Math::Point scale)
 {
-    if (m_backgroundFullTex.Valid())
+    if (m_backgroundTex.Valid())
     {
-        DeleteTexture(m_backgroundFullTex);
-        m_backgroundFullTex.SetInvalid();
-    }
-
-    for (int i = 0; i < 4; i++)
-    {
-        DeleteTexture(m_backgroundQuarterTexs[i]);
-        m_backgroundQuarterTexs[i].SetInvalid();
+        DeleteTexture(m_backgroundTex);
+        m_backgroundTex.SetInvalid();
     }
 
     m_backgroundName      = name;
@@ -2477,28 +2428,15 @@ void Gfx::CEngine::SetBackground(const std::string& name, Gfx::Color up, Gfx::Co
     m_backgroundCloudUp   = cloudUp;
     m_backgroundCloudDown = cloudDown;
     m_backgroundFull      = full;
-    m_backgroundQuarter   = quarter;
+    m_backgroundScale     = scale;
 
     if (! m_backgroundName.empty())
-    {
-        if (m_backgroundQuarter)
-        {
-            for (int i = 0; i < 4; i++)
-            {
-                m_backgroundQuarterNames[i] = QuarterName(name, i);
-                m_backgroundQuarterTexs[i] = LoadTexture(m_backgroundQuarterNames[i]);
-            }
-        }
-        else
-        {
-            m_backgroundFullTex = LoadTexture(m_backgroundName);
-        }
-    }
+        m_backgroundTex = LoadTexture(m_backgroundName);
 }
 
 void Gfx::CEngine::GetBackground(std::string& name, Gfx::Color& up, Gfx::Color& down,
                                  Gfx::Color& cloudUp, Gfx::Color& cloudDown,
-                                 bool &full, bool &quarter)
+                                 bool &full, Math::Point& scale)
 {
     name      = m_backgroundName;
     up        = m_backgroundColorUp;
@@ -2506,7 +2444,7 @@ void Gfx::CEngine::GetBackground(std::string& name, Gfx::Color& up, Gfx::Color&
     cloudUp   = m_backgroundCloudUp;
     cloudDown = m_backgroundCloudDown;
     full      = m_backgroundFull;
-    quarter   = m_backgroundQuarter;
+    scale     = m_backgroundScale;
 }
 
 void Gfx::CEngine::SetForegroundName(const std::string& name)
@@ -3477,10 +3415,16 @@ void Gfx::CEngine::DrawBackgroundGradient(const Gfx::Color& up, const Gfx::Color
     AddStatisticTriangle(2);
 }
 
-// Status: PART_TESTED
-void Gfx::CEngine::DrawBackgroundImageQuarter(Math::Point p1, Math::Point p2, const Gfx::Texture &tex)
+// Status: TESTED, VERIFIED
+void Gfx::CEngine::DrawBackgroundImage()
 {
-    Math::Vector n = Math::Vector(0.0f, 0.0f, -1.0f);  // normal
+    Math::Point p1, p2;
+    p1.x = 0.0f;
+    p1.y = 0.0f;
+    p2.x = 1.0f;
+    p2.y = 1.0f;
+
+Math::Vector n = Math::Vector(0.0f, 0.0f, -1.0f);  // normal
 
     float u1, u2, v1, v2;
     if (m_backgroundFull)
@@ -3489,14 +3433,6 @@ void Gfx::CEngine::DrawBackgroundImageQuarter(Math::Point p1, Math::Point p2, co
         v1 = 0.0f;
         u2 = 1.0f;
         v2 = 1.0f;
-
-        if (m_backgroundQuarter)
-        {
-            u1 += 0.5f/512.0f;
-            v1 += 0.5f/384.0f;
-            u2 -= 0.5f/512.0f;
-            v2 -= 0.5f/384.0f;
-        }
     }
     else
     {
@@ -3513,7 +3449,10 @@ void Gfx::CEngine::DrawBackgroundImageQuarter(Math::Point p1, Math::Point p2, co
         v2 = v1+h;
     }
 
-    SetTexture(tex);
+    u2 *= m_backgroundScale.x;
+    v2 *= m_backgroundScale.y;
+
+    SetTexture(m_backgroundTex);
     SetState(Gfx::ENG_RSTATE_OPAQUE_TEXTURE | Gfx::ENG_RSTATE_WRAP);
 
     m_device->SetTransform(Gfx::TRANSFORM_VIEW, m_matViewInterface);
@@ -3532,48 +3471,6 @@ void Gfx::CEngine::DrawBackgroundImageQuarter(Math::Point p1, Math::Point p2, co
     AddStatisticTriangle(2);
 }
 
-// Status: TESTED, VERIFIED
-void Gfx::CEngine::DrawBackgroundImage()
-{
-    Math::Point p1, p2;
-    std::string name;
-
-    if (m_backgroundQuarter)
-    {
-        p1.x = 0.0f;
-        p1.y = 0.5f;
-        p2.x = 0.5f;
-        p2.y = 1.0f;
-        DrawBackgroundImageQuarter(p1, p2, m_backgroundQuarterTexs[0]);
-
-        p1.x = 0.5f;
-        p1.y = 0.5f;
-        p2.x = 1.0f;
-        p2.y = 1.0f;
-        DrawBackgroundImageQuarter(p1, p2, m_backgroundQuarterTexs[1]);
-
-        p1.x = 0.0f;
-        p1.y = 0.0f;
-        p2.x = 0.5f;
-        p2.y = 0.5f;
-        DrawBackgroundImageQuarter(p1, p2, m_backgroundQuarterTexs[2]);
-
-        p1.x = 0.5f;
-        p1.y = 0.0f;
-        p2.x = 1.0f;
-        p2.y = 0.5f;
-        DrawBackgroundImageQuarter(p1, p2, m_backgroundQuarterTexs[3]);
-    }
-    else
-    {
-        p1.x = 0.0f;
-        p1.y = 0.0f;
-        p2.x = 1.0f;
-        p2.y = 1.0f;
-        DrawBackgroundImageQuarter(p1, p2, m_backgroundFullTex);
-    }
-}
-
 void Gfx::CEngine::DrawPlanet()
 {
     if (! m_planet->PlanetExist()) return;
diff --git a/src/graphics/engine/engine.h b/src/graphics/engine/engine.h
index 1ce93a3..01a1dee 100644
--- a/src/graphics/engine/engine.h
+++ b/src/graphics/engine/engine.h
@@ -991,10 +991,10 @@ public:
     //! Management of the background image to use
     void            SetBackground(const std::string& name, Gfx::Color up = Gfx::Color(), Gfx::Color down = Gfx::Color(),
                                   Gfx::Color cloudUp = Gfx::Color(), Gfx::Color cloudDown = Gfx::Color(),
-                                  bool full = false, bool quarter = false);
+                                  bool full = false, Math::Point scale = Math::Point(1.0f, 1.0f));
     void            GetBackground(std::string& name, Gfx::Color& up, Gfx::Color& down,
                                   Gfx::Color& cloudUp, Gfx::Color& cloudDown,
-                                  bool& full, bool& quarter);
+                                  bool& full, Math::Point& scale);
     //@}
 
     //! Specifies the name of foreground texture
@@ -1154,8 +1154,6 @@ protected:
     void        DrawBackground();
     //! Draws the gradient background
     void        DrawBackgroundGradient(const Gfx::Color& up, const Gfx::Color& down);
-    //! Draws a portion of the image background
-    void        DrawBackgroundImageQuarter(Math::Point p1, Math::Point p2, const Gfx::Texture &tex);
     //! Draws the image background
     void        DrawBackgroundImage();
     //! Draws all the planets
@@ -1290,11 +1288,9 @@ protected:
     bool            m_firstGroundSpot;
     int             m_secondTexNum;
     bool            m_backgroundFull;
-    bool            m_backgroundQuarter;
+    Math::Point     m_backgroundScale;
     std::string     m_backgroundName;
-    std::string     m_backgroundQuarterNames[4];
-    Gfx::Texture    m_backgroundFullTex;
-    Gfx::Texture    m_backgroundQuarterTexs[4];
+    Gfx::Texture    m_backgroundTex;
     Gfx::Color      m_backgroundColorUp;
     Gfx::Color      m_backgroundColorDown;
     Gfx::Color      m_backgroundCloudUp;
diff --git a/src/graphics/opengl/gldevice.cpp b/src/graphics/opengl/gldevice.cpp
index 09efeb3..881e273 100644
--- a/src/graphics/opengl/gldevice.cpp
+++ b/src/graphics/opengl/gldevice.cpp
@@ -436,7 +436,10 @@ Gfx::Texture Gfx::CGLDevice::CreateTexture(ImageData *data, const Gfx::TextureCr
     else
         glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_FALSE);
 
+
+    bool convert = false;
     GLenum sourceFormat = 0;
+
     if (params.format == Gfx::TEX_IMG_RGB)
     {
         sourceFormat = GL_RGB;
@@ -461,26 +464,26 @@ Gfx::Texture Gfx::CGLDevice::CreateTexture(ImageData *data, const Gfx::TextureCr
     {
         if (data->surface->format->Amask != 0)
         {
-            if ((data->surface->format->Rmask == 0xFF000000) &&
-                (data->surface->format->Gmask == 0x00FF0000) &&
-                (data->surface->format->Bmask == 0x0000FF00) &&
-                (data->surface->format->Amask == 0x000000FF))
+            if ((data->surface->format->Amask == 0xFF000000) &&
+                (data->surface->format->Rmask == 0x00FF0000) &&
+                (data->surface->format->Gmask == 0x0000FF00) &&
+                (data->surface->format->Bmask == 0x000000FF))
             {
                 sourceFormat = GL_BGRA;
                 result.alpha = true;
             }
-            else if ((data->surface->format->Bmask == 0xFF000000) &&
-                     (data->surface->format->Gmask == 0x00FF0000) &&
-                     (data->surface->format->Rmask == 0x0000FF00) &&
-                     (data->surface->format->Amask == 0x000000FF))
+            else if ((data->surface->format->Amask == 0xFF000000) &&
+                     (data->surface->format->Bmask == 0x00FF0000) &&
+                     (data->surface->format->Gmask == 0x0000FF00) &&
+                     (data->surface->format->Rmask == 0x000000FF))
             {
                 sourceFormat = GL_RGBA;
                 result.alpha = true;
             }
             else
             {
-                GetLogger()->Error("Auto texture format failed\n");
-                return Gfx::Texture(); // other format?
+                sourceFormat = GL_RGBA;
+                convert = true;
             }
         }
         else
@@ -501,16 +504,43 @@ Gfx::Texture Gfx::CGLDevice::CreateTexture(ImageData *data, const Gfx::TextureCr
             }
             else
             {
-                GetLogger()->Error("Auto texture format failed\n");
-                return Gfx::Texture(); // other format?
+                sourceFormat = GL_RGBA;
+                convert = true;
             }
         }
     }
     else
         assert(false);
 
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, data->surface->w, data->surface->h,
-                 0, sourceFormat, GL_UNSIGNED_BYTE, data->surface->pixels);
+    SDL_Surface* actualSurface = data->surface;
+    SDL_Surface* convertedSurface = nullptr;
+
+    if (convert)
+    {
+        SDL_PixelFormat format;
+        format.BytesPerPixel = 4;
+        format.BitsPerPixel = 32;
+        format.alpha = 0;
+        format.colorkey = 0;
+        format.Aloss = format.Bloss = format.Gloss = format.Rloss = 0;
+        format.Amask = 0xFF000000;
+        format.Ashift = 24;
+        format.Bmask = 0x00FF0000;
+        format.Bshift = 16;
+        format.Gmask = 0x0000FF00;
+        format.Gshift = 8;
+        format.Rmask = 0x000000FF;
+        format.Rshift = 0;
+        format.palette = nullptr;
+        convertedSurface = SDL_ConvertSurface(data->surface, &format, SDL_SWSURFACE);
+        if (convertedSurface != nullptr)
+            actualSurface = convertedSurface;
+    }
+
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, actualSurface->w, actualSurface->h,
+                 0, sourceFormat, GL_UNSIGNED_BYTE, actualSurface->pixels);
+
+    SDL_FreeSurface(convertedSurface);
 
 
     // Restore the previous state of 1st stage