Implement the fisheye effect

Author: adazem009

src/shadermanager.cpp

@@ -32,16 +32,25 @@ static const QString SHADER_PREFIX = "#version 140\n";
 
 static const char *TEXTURE_UNIT_UNIFORM = "u_skin";
 
-static const std::unordered_map<ShaderManager::Effect, const char *>
-    EFFECT_TO_NAME = { { ShaderManager::Effect::Color, "color" }, { ShaderManager::Effect::Brightness, "brightness" }, { ShaderManager::Effect::Ghost, "ghost" } };
+static const std::unordered_map<ShaderManager::Effect, const char *> EFFECT_TO_NAME = {
+    { ShaderManager::Effect::Color, "color" },
+    { ShaderManager::Effect::Brightness, "brightness" },
+    { ShaderManager::Effect::Ghost, "ghost" },
+    { ShaderManager::Effect::Fisheye, "fisheye" }
+};
 
-static const std::unordered_map<ShaderManager::Effect, const char *>
-    EFFECT_UNIFORM_NAME = { { ShaderManager::Effect::Color, "u_color" }, { ShaderManager::Effect::Brightness, "u_brightness" }, { ShaderManager::Effect::Ghost, "u_ghost" } };
+static const std::unordered_map<ShaderManager::Effect, const char *> EFFECT_UNIFORM_NAME = {
+    { ShaderManager::Effect::Color, "u_color" },
+    { ShaderManager::Effect::Brightness, "u_brightness" },
+    { ShaderManager::Effect::Ghost, "u_ghost" },
+    { ShaderManager::Effect::Fisheye, "u_fisheye" }
+};
 
 static const std::unordered_map<ShaderManager::Effect, ConverterFunc> EFFECT_CONVERTER = {
     { ShaderManager::Effect::Color, [](float x) { return wrapClamp(x / 200.0f, 0.0f, 1.0f); } },
     { ShaderManager::Effect::Brightness, [](float x) { return std::clamp(x, -100.0f, 100.0f) / 100.0f; } },
-    { ShaderManager::Effect::Ghost, [](float x) { return 1 - std::clamp(x, 0.0f, 100.0f) / 100.0f; } }
+    { ShaderManager::Effect::Ghost, [](float x) { return 1 - std::clamp(x, 0.0f, 100.0f) / 100.0f; } },
+    { ShaderManager::Effect::Fisheye, [](float x) { return std::max(0.0f, (x + 100.0f) / 100.0f); } }
 };
 
 static const std::unordered_map<ShaderManager::Effect, bool>

src/shadermanager.h

@@ -18,7 +18,8 @@ class ShaderManager : public QObject
         {
             Color = 1 << 0,
             Brightness = 1 << 1,
-            Ghost = 1 << 2
+            Ghost = 1 << 2,
+            Fisheye = 1 << 3
         };
 
         explicit ShaderManager(QObject *parent = nullptr);

src/shaders/sprite.frag

@@ -18,6 +18,10 @@ uniform float u_brightness;
 uniform float u_ghost;
 #endif // ENABLE_ghost
 
+#ifdef ENABLE_fisheye
+uniform float u_fisheye;
+#endif // ENABLE_fisheye
+
 varying vec2 v_texCoord;
 uniform sampler2D u_skin;
 
@@ -89,6 +93,17 @@ void main()
 {
     vec2 texcoord0 = v_texCoord;
 
+    #ifdef ENABLE_fisheye
+    {
+        vec2 vec = (texcoord0 - kCenter) / kCenter;
+        float vecLength = length(vec);
+        float r = pow(min(vecLength, 1.0), u_fisheye) * max(1.0, vecLength);
+        vec2 unit = vec / vecLength;
+
+        texcoord0 = kCenter + r * unit * kCenter;
+    }
+    #endif // ENABLE_fisheye
+
     gl_FragColor = texture2D(u_skin, texcoord0);
 
     #if defined(ENABLE_color) || defined(ENABLE_brightness)

test/shadermanager/shadermanager_test.cpp

@@ -266,3 +266,51 @@ TEST_F(ShaderManagerTest, GhostEffectValue)
 
     program->release();
 }
+
+TEST_F(ShaderManagerTest, FisheyeEffectValue)
+{
+    static const QString effectName = "fisheye";
+    static const QString uniformName = "u_" + effectName;
+    static const ShaderManager::Effect effect = ShaderManager::Effect::Fisheye;
+
+    std::unordered_map<ShaderManager::Effect, float> values;
+
+    QOpenGLFunctions glF(&m_context);
+    glF.initializeOpenGLFunctions();
+    ShaderManager manager;
+
+    // In range
+    std::unordered_map<ShaderManager::Effect, double> effects = { { effect, 58.5 } };
+    QOpenGLShaderProgram *program = manager.getShaderProgram(effects);
+    program->bind();
+    manager.setUniforms(program, 0, effects);
+    manager.getUniformValuesForEffects(effects, values);
+
+    GLfloat value = 0.0f;
+    glF.glGetUniformfv(program->programId(), program->uniformLocation(uniformName), &value);
+    ASSERT_EQ(value, 1.585f);
+    ASSERT_EQ(values.at(effect), value);
+
+    effects[effect] = -20.8;
+    program->bind();
+    manager.setUniforms(program, 0, effects);
+    manager.getUniformValuesForEffects(effects, values);
+
+    value = 0.0f;
+    glF.glGetUniformfv(program->programId(), program->uniformLocation(uniformName), &value);
+    ASSERT_EQ(value, 0.792f);
+    ASSERT_EQ(values.at(effect), value);
+
+    // Below the minimum
+    effects[effect] = -101;
+    program->bind();
+    manager.setUniforms(program, 0, effects);
+    manager.getUniformValuesForEffects(effects, values);
+
+    value = 0.0f;
+    glF.glGetUniformfv(program->programId(), program->uniformLocation(uniformName), &value);
+    ASSERT_EQ(value, 0.0f);
+    ASSERT_EQ(values.at(effect), value);
+
+    program->release();
+}

test/shape_changing_effects.png

@@ -103,6 +103,23 @@ TEST_F(TargetPainterTest, Paint)
     // Compare with reference image
     ASSERT_LE(fuzzyCompareImages(fbo.toImage(), QImage("color_effects.png")), 0.04);
 
+    // Paint with shape changing effects
+    glF.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+    glF.glClear(GL_COLOR_BUFFER_BIT);
+    effects.clear();
+    effects[ShaderManager::Effect::Fisheye] = 46;
+    /*effects[ShaderManager::Effect::Whirl] = 50;
+    effects[ShaderManager::Effect::Pixelate] = 25;
+    effects[ShaderManager::Effect::Mosaic] = 30;*/
+    EXPECT_CALL(target, texture()).WillOnce(Return(texture));
+    EXPECT_CALL(target, graphicEffects()).WillOnce(ReturnRef(effects));
+    targetPainter.paint(&painter);
+    painter.endFrame();
+    effects.clear();
+
+    // Compare with reference image
+    ASSERT_LE(fuzzyCompareImages(fbo.toImage(), QImage("shape_changing_effects.png")), 0.04);
+
     // Release
     fbo.release();
     refFbo.release();