Implement the mosaic effect

Author: adazem009

src/shadermanager.cpp

@@ -36,13 +36,13 @@ static const char *TEXTURE_UNIT_UNIFORM = "u_skin";
 static const char *SKIN_SIZE_UNIFORM = "u_skinSize";
 
 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" }, { ShaderManager::Effect::Whirl, "whirl" },           { ShaderManager::Effect::Pixelate, "pixelate" }
+    { ShaderManager::Effect::Color, "color" }, { ShaderManager::Effect::Brightness, "brightness" }, { ShaderManager::Effect::Ghost, "ghost" },  { ShaderManager::Effect::Fisheye, "fisheye" },
+    { ShaderManager::Effect::Whirl, "whirl" }, { ShaderManager::Effect::Pixelate, "pixelate" },     { ShaderManager::Effect::Mosaic, "mosaic" }
 };
 
 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::Whirl, "u_whirl" },           { ShaderManager::Effect::Pixelate, "u_pixelate" }
+    { ShaderManager::Effect::Color, "u_color" }, { ShaderManager::Effect::Brightness, "u_brightness" }, { ShaderManager::Effect::Ghost, "u_ghost" },  { ShaderManager::Effect::Fisheye, "u_fisheye" },
+    { ShaderManager::Effect::Whirl, "u_whirl" }, { ShaderManager::Effect::Pixelate, "u_pixelate" },     { ShaderManager::Effect::Mosaic, "u_mosaic" }
 };
 
 static const std::unordered_map<ShaderManager::Effect, ConverterFunc> EFFECT_CONVERTER = {
@@ -51,12 +51,13 @@ static const std::unordered_map<ShaderManager::Effect, ConverterFunc> EFFECT_CON
     { 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::Whirl, [](float x) { return x * (float)pi / 180.0f; } },
-    { ShaderManager::Effect::Pixelate, [](float x) { return std::abs(x) / 10.0f; } }
+    { ShaderManager::Effect::Pixelate, [](float x) { return std::abs(x) / 10.0f; } },
+    { ShaderManager::Effect::Mosaic, [](float x) { return std::max(1.0f, std::min(std::round((std::abs(x) + 10.0f) / 10.0f), 512.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 }, { ShaderManager::Effect::Whirl, true },       { ShaderManager::Effect::Pixelate, true }
+    { ShaderManager::Effect::Color, false }, { ShaderManager::Effect::Brightness, false }, { ShaderManager::Effect::Ghost, false }, { ShaderManager::Effect::Fisheye, true },
+    { ShaderManager::Effect::Whirl, true },  { ShaderManager::Effect::Pixelate, true },    { ShaderManager::Effect::Mosaic, true }
 };
 
 Q_GLOBAL_STATIC(ShaderManager, globalInstance)

src/shadermanager.h

@@ -21,7 +21,8 @@ class ShaderManager : public QObject
             Ghost = 1 << 2,
             Fisheye = 1 << 3,
             Whirl = 1 << 4,
-            Pixelate = 1 << 5
+            Pixelate = 1 << 5,
+            Mosaic = 1 << 6
         };
 
         explicit ShaderManager(QObject *parent = nullptr);

src/shaders/sprite.frag

@@ -31,6 +31,10 @@ uniform float u_pixelate;
 uniform vec2 u_skinSize;
 #endif // ENABLE_pixelate
 
+#ifdef ENABLE_mosaic
+uniform float u_mosaic;
+#endif // ENABLE_mosaic
+
 varying vec2 v_texCoord;
 uniform sampler2D u_skin;
 
@@ -102,6 +106,10 @@ void main()
 {
     vec2 texcoord0 = v_texCoord;
 
+    #ifdef ENABLE_mosaic
+    texcoord0 = fract(u_mosaic * texcoord0);
+    #endif // ENABLE_mosaic
+
     #ifdef ENABLE_pixelate
     {
         // TODO: clean up "pixel" edges

test/shadermanager/shadermanager_test.cpp

@@ -388,3 +388,62 @@ TEST_F(ShaderManagerTest, PixelateEffectValue)
 
     program->release();
 }
+
+TEST_F(ShaderManagerTest, MosaicEffectValue)
+{
+    static const QString effectName = "mosaic";
+    static const QString uniformName = "u_" + effectName;
+    static const ShaderManager::Effect effect = ShaderManager::Effect::Mosaic;
+
+    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, QSize(), effects);
+    manager.getUniformValuesForEffects(effects, values);
+
+    GLfloat value = 0.0f;
+    glF.glGetUniformfv(program->programId(), program->uniformLocation(uniformName), &value);
+    ASSERT_EQ(value, 7.0f);
+    ASSERT_EQ(values.at(effect), value);
+
+    effects[effect] = -21.8;
+    program->bind();
+    manager.setUniforms(program, 0, QSize(), effects);
+    manager.getUniformValuesForEffects(effects, values);
+
+    value = 0.0f;
+    glF.glGetUniformfv(program->programId(), program->uniformLocation(uniformName), &value);
+    ASSERT_EQ(value, 3.0f);
+    ASSERT_EQ(values.at(effect), value);
+
+    // Below the minimum
+    effects[effect] = 4;
+    program->bind();
+    manager.setUniforms(program, 0, QSize(), effects);
+    manager.getUniformValuesForEffects(effects, values);
+
+    value = 0.0f;
+    glF.glGetUniformfv(program->programId(), program->uniformLocation(uniformName), &value);
+    ASSERT_EQ(value, 1.0f);
+    ASSERT_EQ(values.at(effect), value);
+
+    // Above the maximum
+    effects[effect] = 5120;
+    program->bind();
+    manager.setUniforms(program, 0, QSize(), effects);
+    manager.getUniformValuesForEffects(effects, values);
+
+    value = 0.0f;
+    glF.glGetUniformfv(program->programId(), program->uniformLocation(uniformName), &value);
+    ASSERT_EQ(value, 512.0f);
+    ASSERT_EQ(values.at(effect), value);
+
+    program->release();
+}

test/shape_changing_effects.png

@@ -112,7 +112,7 @@ TEST_F(TargetPainterTest, Paint)
     effects[ShaderManager::Effect::Fisheye] = 46;
     effects[ShaderManager::Effect::Whirl] = 50;
     effects[ShaderManager::Effect::Pixelate] = 25;
-    // effects[ShaderManager::Effect::Mosaic] = 30;
+    effects[ShaderManager::Effect::Mosaic] = 30;
     EXPECT_CALL(target, texture()).WillOnce(Return(texture));
     EXPECT_CALL(target, cpuTexture()).WillOnce(ReturnRef(texture));
     EXPECT_CALL(target, graphicEffects()).WillOnce(ReturnRef(effects));