Implement the whirl effect

Author: adazem009

src/shadermanager.cpp

@@ -12,6 +12,8 @@ using namespace scratchcpprender;
 
 using ConverterFunc = float (*)(float);
 
+static const double pi = std::acos(-1); // TODO: Use std::numbers::pi in C++20
+
 static float wrapClamp(float n, float min, float max)
 {
     // TODO: Move this to a separate class
@@ -36,25 +38,33 @@ static const std::unordered_map<ShaderManager::Effect, const char *> EFFECT_TO_N
     { ShaderManager::Effect::Color, "color" },
     { ShaderManager::Effect::Brightness, "brightness" },
     { ShaderManager::Effect::Ghost, "ghost" },
-    { ShaderManager::Effect::Fisheye, "fisheye" }
+    { ShaderManager::Effect::Fisheye, "fisheye" },
+    { ShaderManager::Effect::Whirl, "whirl" }
 };
 
 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" }
+    { ShaderManager::Effect::Fisheye, "u_fisheye" },
+    { ShaderManager::Effect::Whirl, "u_whirl" }
 };
 
 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::Fisheye, [](float x) { return std::max(0.0f, (x + 100.0f) / 100.0f); } }
+    { ShaderManager::Effect::Fisheye, [](float x) { return std::max(0.0f, (x + 100.0f) / 100.0f); } },
+    { ShaderManager::Effect::Whirl, [](float x) { return x * (float)pi / 180.0f; } }
 };
 
-static const std::unordered_map<ShaderManager::Effect, bool>
-    EFFECT_SHAPE_CHANGES = { { ShaderManager::Effect::Color, false }, { ShaderManager::Effect::Brightness, false }, { ShaderManager::Effect::Ghost, false }, { ShaderManager::Effect::Fisheye, true } };
+static const std::unordered_map<ShaderManager::Effect, bool> EFFECT_SHAPE_CHANGES = {
+    { ShaderManager::Effect::Color, false },
+    { ShaderManager::Effect::Brightness, false },
+    { ShaderManager::Effect::Ghost, false },
+    { ShaderManager::Effect::Fisheye, true },
+    { ShaderManager::Effect::Whirl, true }
+};
 
 Q_GLOBAL_STATIC(ShaderManager, globalInstance)
 

src/shadermanager.h

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

src/shaders/sprite.frag

@@ -22,6 +22,10 @@ uniform float u_ghost;
 uniform float u_fisheye;
 #endif // ENABLE_fisheye
 
+#ifdef ENABLE_whirl
+uniform float u_whirl;
+#endif // ENABLE_whirl
+
 varying vec2 v_texCoord;
 uniform sampler2D u_skin;
 
@@ -93,6 +97,24 @@ void main()
 {
     vec2 texcoord0 = v_texCoord;
 
+    #ifdef ENABLE_whirl
+    {
+        const float kRadius = 0.5;
+        vec2 offset = texcoord0 - kCenter;
+        float offsetMagnitude = length(offset);
+        float whirlFactor = max(1.0 - (offsetMagnitude / kRadius), 0.0);
+        float whirlActual = u_whirl * whirlFactor * whirlFactor;
+        float sinWhirl = sin(whirlActual);
+        float cosWhirl = cos(whirlActual);
+        mat2 rotationMatrix = mat2(
+            cosWhirl, -sinWhirl,
+            sinWhirl, cosWhirl
+        );
+
+        texcoord0 = rotationMatrix * offset + kCenter;
+    }
+    #endif // ENABLE_whirl
+
     #ifdef ENABLE_fisheye
     {
         vec2 vec = (texcoord0 - kCenter) / kCenter;

test/shadermanager/shadermanager_test.cpp

@@ -314,3 +314,40 @@ TEST_F(ShaderManagerTest, FisheyeEffectValue)
 
     program->release();
 }
+
+TEST_F(ShaderManagerTest, WhirlEffectValue)
+{
+    static const QString effectName = "whirl";
+    static const QString uniformName = "u_" + effectName;
+    static const ShaderManager::Effect effect = ShaderManager::Effect::Whirl;
+
+    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(std::round(value * 1000) / 1000, 1.021f);
+    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(std::round(value * 1000) / 1000, -0.363f);
+    ASSERT_EQ(values.at(effect), value);
+
+    program->release();
+}

test/shape_changing_effects.png

@@ -108,8 +108,8 @@ TEST_F(TargetPainterTest, Paint)
     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::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));