X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=effect_chain_test.cpp;h=f51f988bdad220a3b4c259ec55a9eaea477bc844;hp=3a3811da156539c25b853756efa76b5c6d6d30ff;hb=88e9f85b9e48e05f0f9d35d199db03e5352919c4;hpb=a2e7b432626b8a2c54cb1ff9d09203f50227fc07 diff --git a/effect_chain_test.cpp b/effect_chain_test.cpp index 3a3811d..f51f988 100644 --- a/effect_chain_test.cpp +++ b/effect_chain_test.cpp @@ -154,7 +154,8 @@ public: template class RewritingEffect : public Effect { public: - RewritingEffect() : effect(new T()), replaced_node(nullptr) {} + template + RewritingEffect(Args &&... args) : effect(new T(std::forward(args)...)), replaced_node(nullptr) {} string effect_type_id() const override { return "RewritingEffect[" + effect->effect_type_id() + "]"; } string output_fragment_shader() override { EXPECT_TRUE(false); return read_file("identity.frag"); } void rewrite_graph(EffectChain *graph, Node *self) override { @@ -565,7 +566,7 @@ TEST(EffectChainTest, AlphaConversionsWithNonBlankAlphaPreservingEffect) { class MipmapNeedingEffect : public Effect { public: MipmapNeedingEffect() {} - bool needs_mipmaps() const override { return true; } + MipmapRequirements needs_mipmaps() const override { return NEEDS_MIPMAPS; } // To be allowed to mess with the sampler state. bool needs_texture_bounce() const override { return true; } @@ -773,6 +774,74 @@ TEST(EffectChainTest, ResizeDownByFourThenUpByFour) { expect_equal(expected_data, out_data, 4, 16); } +// An effect to verify that you can turn off mipmaps; it downscales by two, +// which gives blur with mipmaps and aliasing (picks out every other pixel) +// without. +class Downscale2xEffect : public Effect { +public: + explicit Downscale2xEffect(MipmapRequirements mipmap_requirements) + : mipmap_requirements(mipmap_requirements) + { + register_vec2("offset", offset); + } + MipmapRequirements needs_mipmaps() const override { return mipmap_requirements; } + + string effect_type_id() const override { return "Downscale2xEffect"; } + string output_fragment_shader() override { return read_file("downscale2x.frag"); } + +private: + const MipmapRequirements mipmap_requirements; + EffectChain *chain; + float offset[2] { 0.0f, 0.0f }; +}; + +TEST(EffectChainTest, MipmapChainGetsSplit) { + float data[] = { + 0.0f, 0.0f, 0.0f, 0.0f, + 1.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 0.0f, + 1.0f, 0.0f, 1.0f, 0.0f, + }; + + // The intermediate result after the first step looks like this, + // assuming there are no mipmaps (the zeros are due to border behavior): + // + // 0 0 0 0 + // 0 0 0 0 + // 1 1 0 0 + // 1 1 0 0 + // + // so another 2x downscale towards the bottom left will give + // + // 0 0 + // 1 0 + // + // with yet more zeros coming in on the top and the right from the border. + float expected_data[] = { + 0.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 0.0f, + 1.0f, 0.0f, 0.0f, 0.0f, + }; + float out_data[4 * 4]; + + float offset[] = { -0.5f / 4.0f, -0.5f / 4.0f }; + RewritingEffect *pick_out_bottom_left = new RewritingEffect(Effect::CANNOT_ACCEPT_MIPMAPS); + ASSERT_TRUE(pick_out_bottom_left->effect->set_vec2("offset", offset)); + + RewritingEffect *downscale2x = new RewritingEffect(Effect::NEEDS_MIPMAPS); + + EffectChainTester tester(data, 4, 4, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR); + tester.get_chain()->add_effect(pick_out_bottom_left); + tester.get_chain()->add_effect(downscale2x); + tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR); + + EXPECT_NE(pick_out_bottom_left->replaced_node->containing_phase, + downscale2x->replaced_node->containing_phase); + + expect_equal(expected_data, out_data, 4, 4); +} + // An effect that adds its two inputs together. Used below. class AddEffect : public Effect { public: @@ -882,6 +951,78 @@ TEST(EffectChainTest, DiamondGraphWithOneInputUsedInTwoPhases) { expect_equal(expected_data, out_data, 2, 2); } +// Constructs the graph +// +// FlatInput | +// / \ | +// Downscale2xEffect (mipmaps) Downscale2xEffect (no mipmaps) | +// | | | +// Downscale2xEffect (mipmaps) Downscale2xEffect (no mipmaps) | +// \ / | +// AddEffect | +// +// and verifies that it gives the correct output. Due to the conflicting +// mipmap demands, EffectChain needs to make two phases; exactly where it's +// split is less important, though (this is a fairly obscure situation that +// is unlikely to happen in practice). +TEST(EffectChainTest, DiamondGraphWithConflictingMipmaps) { + float data[] = { + 0.0f, 0.0f, 0.0f, 0.0f, + 1.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 0.0f, + 1.0f, 0.0f, 1.0f, 0.0f, + }; + + // Same situation as MipmapChainGetsSplit. The output of the two + // downscales with no mipmaps looks like this: + // + // 0 0 0 0 + // 0 0 0 0 + // 0 0 0 0 + // 1 0 0 0 + // + // and the one with mipmaps is 0.25 everywhere. Due to postmultiplied + // alpha, we get the average even though we are using AddEffect. + float expected_data[] = { + 0.125f, 0.125f, 0.125f, 0.125f, + 0.125f, 0.125f, 0.125f, 0.125f, + 0.125f, 0.125f, 0.125f, 0.125f, + 0.625f, 0.125f, 0.125f, 0.125f, + }; + float out_data[4 * 4]; + + float offset[] = { -0.5f / 4.0f, -0.5f / 4.0f }; + Downscale2xEffect *nomipmap1 = new Downscale2xEffect(Effect::CANNOT_ACCEPT_MIPMAPS); + Downscale2xEffect *nomipmap2 = new Downscale2xEffect(Effect::CANNOT_ACCEPT_MIPMAPS); + ASSERT_TRUE(nomipmap1->set_vec2("offset", offset)); + ASSERT_TRUE(nomipmap2->set_vec2("offset", offset)); + + Downscale2xEffect *mipmap1 = new Downscale2xEffect(Effect::NEEDS_MIPMAPS); + Downscale2xEffect *mipmap2 = new Downscale2xEffect(Effect::NEEDS_MIPMAPS); + + EffectChainTester tester(nullptr, 4, 4); + + ImageFormat format; + format.color_space = COLORSPACE_sRGB; + format.gamma_curve = GAMMA_LINEAR; + + FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, 4, 4); + input->set_pixel_data(data); + + tester.get_chain()->add_input(input); + + tester.get_chain()->add_effect(nomipmap1, input); + tester.get_chain()->add_effect(nomipmap2, nomipmap1); + + tester.get_chain()->add_effect(mipmap1, input); + tester.get_chain()->add_effect(mipmap2, mipmap1); + + tester.get_chain()->add_effect(new AddEffect(), nomipmap2, mipmap2); + tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR); + + expect_equal(expected_data, out_data, 4, 4); +} + TEST(EffectChainTest, EffectUsedTwiceOnlyGetsOneGammaConversion) { float data[] = { 0.735f, 0.0f,