Bugfix: consider player walking while using map shader

data/shaders/map_snow_fragment.frag

@@ -0,0 +1,25 @@
+
+varying vec2 v_TexCoord;
+
+uniform vec4 u_Color;
+uniform sampler2D u_Tex0;
+uniform sampler2D u_Tex1;
+uniform float u_Time;
+uniform vec2 u_WalkOffset;
+
+vec2 snowDirection = vec2(1.0, 0.2);
+float snowSpeed = 0.08;
+float snowPressure = 0.4;
+float snowZoom = 0.6;
+
+void main()
+{
+    gl_FragColor = texture2D(u_Tex0, v_TexCoord) * u_Color;
+
+    vec2 snowCoord = (v_TexCoord + vec2(u_WalkOffset.x, u_WalkOffset.y) + (snowDirection * u_Time * snowSpeed)) / snowZoom;
+    vec4 effectPixel = texture2D(u_Tex1, snowCoord) * snowPressure;
+
+    gl_FragColor += (effectPixel.rgba);
+    if(gl_FragColor.a < 0.01)
+        discard;
+}

data/shaders/map_snow_vertex.frag

@@ -0,0 +1,19 @@
+attribute vec2 a_TexCoord;
+attribute vec2 a_Vertex;
+
+varying vec2 v_TexCoord;
+varying vec2 v_TexCoord2;
+
+uniform mat3 u_TextureMatrix;
+uniform mat3 u_TransformMatrix;
+uniform mat3 u_ProjectionMatrix;
+
+uniform vec2 u_Offset;
+uniform vec2 u_Center;
+
+void main()
+{
+    gl_Position = vec4((u_ProjectionMatrix * u_TransformMatrix * vec3(a_Vertex.xy, 1.0)).xy, 1.0, 1.0);
+    v_TexCoord = (u_TextureMatrix * vec3(a_TexCoord,1.0)).xy;
+}
+

modules/game_shaders/shaders.lua

@@ -6,6 +6,9 @@ function init()
 
   g_shaders.createShader("map_rainbow", "/shaders/map_rainbow_vertex", "/shaders/map_rainbow_fragment")
   g_shaders.addTexture("map_rainbow", "/images/shaders/rainbow.png")
+
+  g_shaders.createShader("map_snow", "/shaders/map_snow_vertex", "/shaders/map_snow_fragment")
+  g_shaders.addTexture("map_snow", "/images/shaders/snow.png")
 
   -- use modules.game_interface.gameMapPanel:setShader("map_rainbow") to set shader
 

src/client/mapview.cpp

@@ -155,7 +155,27 @@ void MapView::drawMapBackground(const Rect& rect, const TilePtr& crosshairTile)
             g_drawQueue->setOpacity(floorStart, fading);
     }
 
-} 
+    if(!m_shader.empty() && isFollowingCreature()) {
+        g_drawQueue->setShader(m_shader);
+
+        Point walkOffset = transformPositionTo2D(getCameraPosition(), m_shaderPosition);
+        walkOffset.y = -walkOffset.y;
+
+        g_drawQueue->setWalkOffset(
+            PointF(
+                (walkOffset.x / static_cast<float>(m_optimizedSize.width())),
+                (walkOffset.y / static_cast<float>(m_optimizedSize.height()))
+            )
+        );
+    }
+}
+
+void MapView::setShader(const std::string& shader)
+{
+    m_shader = shader;
+    if (!m_shader.empty())
+        m_shaderPosition = getCameraPosition();
+}
 
 void MapView::drawFloor(short floor, const Position& cameraPosition, const TilePtr& crosshairTile)
 {

src/client/mapview.h

@@ -113,8 +113,11 @@ class MapView : public LuaObject
     void setFloorFading(int value) { m_floorFading = value; }
     void setCrosshair(const std::string& file);
 
-    //void setShader(const PainterShaderProgramPtr& shader, float fadein, float fadeout);
-    //PainterShaderProgramPtr getShader() { return m_shader; }
+    void setShader(const std::string& shader);
+    std::string getShader()
+    {
+        return m_shader;
+    }
 
     Position getPosition(const Point& point, const Size& mapSize);
 
@@ -156,6 +159,9 @@ class MapView : public LuaObject
     bool m_drawPlayerBars = true;
     stdext::boolean<true> m_smooth;
 
+    std::string m_shader;
+    Position m_shaderPosition;
+
     stdext::timer m_fadingFloorTimers[Otc::MAX_Z + 1];
 
     stdext::boolean<true> m_follow;

src/client/uimap.cpp

@@ -65,9 +65,6 @@ void UIMap::drawSelf(Fw::DrawPane drawPane)
         g_drawQueue->markMapPosition();
     } else if(drawPane == Fw::MapBackgroundPane) {
         m_mapView->drawMapBackground(m_mapRect, getTile(m_mousePosition));
-        if (!m_shader.empty()) {
-            g_drawQueue->setShader(m_shader);
-        }
     } else if (drawPane == Fw::MapForegroundPane) {
         m_mapView->drawMapForeground(m_mapRect);
     }

src/client/uimap.h

@@ -91,11 +91,14 @@ class UIMap : public UIWidget
 
     void setShader(const std::string& shader)
     {
-        m_shader = shader;
+        if(m_mapView)
+            m_mapView->setShader(shader);
     }
     std::string getShader()
     {
-        return m_shader;
+        if(m_mapView)
+            return m_mapView->getShader();
+        return "";
     }
 
 protected:
@@ -115,7 +118,6 @@ class UIMap : public UIWidget
     bool m_limitVisibleRange;
     int m_maxZoomIn;
     int m_maxZoomOut;
-    std::string m_shader;
 };
 
 #endif

src/framework/core/graphicalapplication.cpp

@@ -286,6 +286,11 @@ void GraphicalApplication::run()
                 PainterShaderProgramPtr shader = nullptr;
                 if (!toDrawMapQueue->getShader().empty()) {
                     shader = g_shaders.getShader(toDrawMapQueue->getShader());
+
+                    if(shader) {
+                        auto walkOffset = toDrawMapQueue->getWalkOffset();
+                        shader->updateWalkOffset(walkOffset);
+                    }
                 }
                 if (shader) {
                     g_painter->setShaderProgram(shader);

src/framework/graphics/drawqueue.h

@@ -327,6 +327,16 @@ class DrawQueue {
         return m_shader;
     }
 
+    void setWalkOffset(const PointF& offset)
+    {
+        m_walkOffset = offset;
+    }
+
+    const PointF& getWalkOffset()
+    {
+        return m_walkOffset;
+    }
+
 private:
     std::vector<DrawQueueItem*> m_queue;
     std::vector<DrawQueueCondition*> m_conditions;
@@ -336,6 +346,7 @@ class DrawQueue {
     bool m_useFrameBuffer = false;
     float m_scaling = 1.f;
     std::string m_shader;
+    PointF m_walkOffset;
 
     friend struct DrawQueueConditionMark;
 };

src/framework/graphics/paintershaderprogram.cpp

@@ -58,6 +58,8 @@ void PainterShaderProgram::setupUniforms()
     bindUniformLocation(OFFSET_UNIFORM, "u_Offset");
     bindUniformLocation(CENTER_UNIFORM, "u_Center");
 
+    bindUniformLocation(MAP_WALKOFFSET_UNIFORM, "u_WalkOffset");
+
     // VALUES
     setUniformValue(TRANSFORM_MATRIX_UNIFORM, m_transformMatrix);
     setUniformValue(PROJECTION_MATRIX_UNIFORM, m_projectionMatrix);
@@ -80,6 +82,7 @@ void PainterShaderProgram::setupUniforms()
     setUniformValue(RESOLUTION_UNIFORM, (float)m_resolution.width(), (float)m_resolution.height());
     setUniformValue(OFFSET_UNIFORM, (float)m_offset.x, (float)m_offset.y);
     setUniformValue(CENTER_UNIFORM, (float)m_center.x, (float)m_center.y);
+    setUniformValue(MAP_WALKOFFSET_UNIFORM, (float)m_walkOffset.x, (float)m_walkOffset.y);
 }
 
 bool PainterShaderProgram::link()
@@ -202,6 +205,17 @@ void PainterShaderProgram::updateTime()
     m_time = time;
 }
 
+void PainterShaderProgram::updateWalkOffset(const PointF& offset)
+{
+    if (m_walkOffset == offset)
+        return;
+
+    m_walkOffset = offset;
+
+    bind();
+    setUniformValue(MAP_WALKOFFSET_UNIFORM, m_walkOffset.x, m_walkOffset.y);
+}
+
 void PainterShaderProgram::addMultiTexture(const std::string& file)
 {
     if (m_multiTextures.size() > 3)

src/framework/graphics/paintershaderprogram.h

@@ -53,7 +53,8 @@ class PainterShaderProgram : public ShaderProgram {
 
         RESOLUTION_UNIFORM = 13,
         OFFSET_UNIFORM = 14,
-        CENTER_UNIFORM = 15
+        CENTER_UNIFORM = 15,
+        MAP_WALKOFFSET_UNIFORM = 16
     };
 
     friend class Painter;
@@ -75,6 +76,7 @@ class PainterShaderProgram : public ShaderProgram {
     void setOffset(const Point& offset);
     void setCenter(const Point& center);
     void updateTime();
+    void updateWalkOffset(const PointF& offset);
 
     void addMultiTexture(const std::string& file);
     void bindMultiTextures();
@@ -95,6 +97,7 @@ class PainterShaderProgram : public ShaderProgram {
     Matrix3 m_textureMatrix;
     Size m_resolution;
     Point m_offset;
+    PointF m_walkOffset;
     Point m_center;
     float m_time;
     std::vector<TexturePtr> m_multiTextures;