SFML/examples/shader/Shader.cpp

////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include "Effect.hpp"

#include <array>
#include <random>


namespace
{
std::random_device rd;
std::mt19937       rng(rd());
} // namespace

const sf::Font* Effect::s_font = nullptr;

////////////////////////////////////////////////////////////
// "Pixelate" fragment shader
////////////////////////////////////////////////////////////
class Pixelate : public Effect
{
public:
    Pixelate() : Effect("Pixelate")
    {
    }

    bool onLoad() override
    {
        // Load the texture and initialize the sprite
        if (!m_texture.loadFromFile("resources/background.jpg"))
            return false;
        m_sprite.emplace(m_texture);

        // Load the shader
        if (!m_shader.loadFromFile("resources/pixelate.frag", sf::Shader::Type::Fragment))
            return false;
        m_shader.setUniform("texture", sf::Shader::CurrentTexture);

        return true;
    }

    void onUpdate(float, float x, float y) override
    {
        m_shader.setUniform("pixel_threshold", (x + y) / 30);
    }

    void onDraw(sf::RenderTarget& target, const sf::RenderStates& states) const override
    {
        sf::RenderStates statesCopy(states);
        statesCopy.shader = &m_shader;
        target.draw(*m_sprite, statesCopy);
    }

private:
    sf::Texture               m_texture;
    std::optional<sf::Sprite> m_sprite;
    sf::Shader                m_shader;
};


////////////////////////////////////////////////////////////
// "Wave" vertex shader + "blur" fragment shader
////////////////////////////////////////////////////////////
class WaveBlur : public Effect
{
public:
    WaveBlur() : Effect("Wave + Blur"), m_text(getFont())
    {
    }

    bool onLoad() override
    {
        // Create the text
        m_text.setString(
            "Praesent suscipit augue in velit pulvinar hendrerit varius purus aliquam.\n"
            "Mauris mi odio, bibendum quis fringilla a, laoreet vel orci. Proin vitae vulputate tortor.\n"
            "Praesent cursus ultrices justo, ut feugiat ante vehicula quis.\n"
            "Donec fringilla scelerisque mauris et viverra.\n"
            "Maecenas adipiscing ornare scelerisque. Nullam at libero elit.\n"
            "Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.\n"
            "Nullam leo urna, tincidunt id semper eget, ultricies sed mi.\n"
            "Morbi mauris massa, commodo id dignissim vel, lobortis et elit.\n"
            "Fusce vel libero sed neque scelerisque venenatis.\n"
            "Integer mattis tincidunt quam vitae iaculis.\n"
            "Vivamus fringilla sem non velit venenatis fermentum.\n"
            "Vivamus varius tincidunt nisi id vehicula.\n"
            "Integer ullamcorper, enim vitae euismod rutrum, massa nisl semper ipsum,\n"
            "vestibulum sodales sem ante in massa.\n"
            "Vestibulum in augue non felis convallis viverra.\n"
            "Mauris ultricies dolor sed massa convallis sed aliquet augue fringilla.\n"
            "Duis erat eros, porta in accumsan in, blandit quis sem.\n"
            "In hac habitasse platea dictumst. Etiam fringilla est id odio dapibus sit amet semper dui laoreet.\n");
        m_text.setCharacterSize(22);
        m_text.setPosition({30.f, 20.f});

        // Load the shader
        return m_shader.loadFromFile("resources/wave.vert", "resources/blur.frag");
    }

    void onUpdate(float time, float x, float y) override
    {
        m_shader.setUniform("wave_phase", time);
        m_shader.setUniform("wave_amplitude", sf::Vector2f(x * 40, y * 40));
        m_shader.setUniform("blur_radius", (x + y) * 0.008f);
    }

    void onDraw(sf::RenderTarget& target, const sf::RenderStates& states) const override
    {
        sf::RenderStates statesCopy(states);
        statesCopy.shader = &m_shader;
        target.draw(m_text, statesCopy);
    }

private:
    sf::Text   m_text;
    sf::Shader m_shader;
};


////////////////////////////////////////////////////////////
// "Storm" vertex shader + "blink" fragment shader
////////////////////////////////////////////////////////////
class StormBlink : public Effect
{
public:
    StormBlink() : Effect("Storm + Blink")
    {
    }

    bool onLoad() override
    {
        std::uniform_real_distribution<float>        xDistribution(0, 800);
        std::uniform_real_distribution<float>        yDistribution(0, 600);
        std::uniform_int_distribution<std::uint16_t> colorDistribution(0, 255);

        // Create the points
        m_points.setPrimitiveType(sf::PrimitiveType::Points);
        for (int i = 0; i < 40000; ++i)
        {
            const auto x = xDistribution(rng);
            const auto y = yDistribution(rng);
            const auto r = static_cast<std::uint8_t>(colorDistribution(rng));
            const auto g = static_cast<std::uint8_t>(colorDistribution(rng));
            const auto b = static_cast<std::uint8_t>(colorDistribution(rng));
            m_points.append(sf::Vertex(sf::Vector2f(x, y), sf::Color(r, g, b)));
        }

        // Load the shader
        return m_shader.loadFromFile("resources/storm.vert", "resources/blink.frag");
    }

    void onUpdate(float time, float x, float y) override
    {
        const float radius = 200 + std::cos(time) * 150;
        m_shader.setUniform("storm_position", sf::Vector2f(x * 800, y * 600));
        m_shader.setUniform("storm_inner_radius", radius / 3);
        m_shader.setUniform("storm_total_radius", radius);
        m_shader.setUniform("blink_alpha", 0.5f + std::cos(time * 3) * 0.25f);
    }

    void onDraw(sf::RenderTarget& target, const sf::RenderStates& states) const override
    {
        sf::RenderStates statesCopy(states);
        statesCopy.shader = &m_shader;
        target.draw(m_points, statesCopy);
    }

private:
    sf::VertexArray m_points;
    sf::Shader      m_shader;
};


////////////////////////////////////////////////////////////
// "Edge" post-effect fragment shader
////////////////////////////////////////////////////////////
class Edge : public Effect
{
public:
    Edge() : Effect("Edge Post-effect")
    {
    }

    bool onLoad() override
    {
        // Create the off-screen surface
        if (!m_surface.create({800, 600}))
            return false;
        m_surface.setSmooth(true);

        // Load the textures
        if (!m_backgroundTexture.loadFromFile("resources/sfml.png"))
            return false;
        m_backgroundTexture.setSmooth(true);
        if (!m_entityTexture.loadFromFile("resources/devices.png"))
            return false;
        m_entityTexture.setSmooth(true);

        // Initialize the background sprite
        m_backgroundSprite.emplace(m_backgroundTexture);
        m_backgroundSprite->setPosition({135.f, 100.f});

        // Load the moving entities
        for (int i = 0; i < 6; ++i)
        {
            const sf::Sprite entity(m_entityTexture, sf::IntRect({96 * i, 0}, {96, 96}));
            m_entities.push_back(entity);
        }

        // Load the shader
        if (!m_shader.loadFromFile("resources/edge.frag", sf::Shader::Type::Fragment))
            return false;
        m_shader.setUniform("texture", sf::Shader::CurrentTexture);

        return true;
    }

    void onUpdate(float time, float x, float y) override
    {
        m_shader.setUniform("edge_threshold", 1 - (x + y) / 2);

        // Update the position of the moving entities
        for (std::size_t i = 0; i < m_entities.size(); ++i)
        {
            sf::Vector2f position;
            position.x = std::cos(0.25f * (time * static_cast<float>(i) + static_cast<float>(m_entities.size() - i))) * 300 +
                         350;
            position.y = std::sin(0.25f * (time * static_cast<float>(m_entities.size() - i) + static_cast<float>(i))) * 200 +
                         250;
            m_entities[i].setPosition(position);
        }

        // Render the updated scene to the off-screen surface
        m_surface.clear(sf::Color::White);
        m_surface.draw(*m_backgroundSprite);
        for (const sf::Sprite& entity : m_entities)
            m_surface.draw(entity);
        m_surface.display();
    }

    void onDraw(sf::RenderTarget& target, const sf::RenderStates& states) const override
    {
        sf::RenderStates statesCopy(states);
        statesCopy.shader = &m_shader;
        target.draw(sf::Sprite(m_surface.getTexture()), statesCopy);
    }

private:
    sf::RenderTexture         m_surface;
    sf::Texture               m_backgroundTexture;
    sf::Texture               m_entityTexture;
    std::optional<sf::Sprite> m_backgroundSprite;
    std::vector<sf::Sprite>   m_entities;
    sf::Shader                m_shader;
};


////////////////////////////////////////////////////////////
// "Geometry" geometry shader example
////////////////////////////////////////////////////////////
class Geometry : public Effect
{
public:
    Geometry() : Effect("Geometry Shader Billboards"), m_pointCloud(sf::PrimitiveType::Points, 10000)
    {
    }

    bool onLoad() override
    {
        // Check if geometry shaders are supported
        if (!sf::Shader::isGeometryAvailable())
            return false;

        // Move the points in the point cloud to random positions
        for (std::size_t i = 0; i < 10000; ++i)
        {
            // Spread the coordinates from -480 to +480
            // So they'll always fill the viewport at 800x600
            std::uniform_real_distribution<float> positionDistribution(-480, 480);
            m_pointCloud[i].position = {positionDistribution(rng), positionDistribution(rng)};
        }

        // Load the texture
        if (!m_logoTexture.loadFromFile("resources/logo.png"))
            return false;

        // Load the shader
        if (!m_shader.loadFromFile("resources/billboard.vert", "resources/billboard.geom", "resources/billboard.frag"))
            return false;
        m_shader.setUniform("texture", sf::Shader::CurrentTexture);

        // Set the render resolution (used for proper scaling)
        m_shader.setUniform("resolution", sf::Vector2f(800, 600));

        return true;
    }

    void onUpdate(float /*time*/, float x, float y) override
    {
        // Reset our transformation matrix
        m_transform = sf::Transform::Identity;
        // Move to the center of the window
        m_transform.translate({400.f, 300.f});
        // Rotate everything based on cursor position
        m_transform.rotate(sf::degrees(x * 360.f));

        // Adjust billboard size to scale between 25 and 75
        const float size = 25 + std::abs(y) * 50;

        // Update the shader parameter
        m_shader.setUniform("size", sf::Vector2f(size, size));
    }

    void onDraw(sf::RenderTarget& target, const sf::RenderStates& states) const override
    {
        sf::RenderStates statesCopy(states);

        // Prepare the render state
        statesCopy.shader    = &m_shader;
        statesCopy.texture   = &m_logoTexture;
        statesCopy.transform = m_transform;

        // Draw the point cloud
        target.draw(m_pointCloud, statesCopy);
    }

private:
    sf::Texture     m_logoTexture;
    sf::Transform   m_transform;
    sf::Shader      m_shader;
    sf::VertexArray m_pointCloud;
};


////////////////////////////////////////////////////////////
/// Entry point of application
///
/// \return Application exit code
///
////////////////////////////////////////////////////////////
int main()
{
    // Create the main window
    sf::RenderWindow window(sf::VideoMode({800, 600}), "SFML Shader", sf::Style::Titlebar | sf::Style::Close);
    window.setVerticalSyncEnabled(true);

    // Load the application font and pass it to the Effect class
    sf::Font font;
    if (!font.loadFromFile("resources/tuffy.ttf"))
        return EXIT_FAILURE;
    Effect::setFont(font);

    // Create the effects
    Pixelate   pixelateEffect;
    WaveBlur   waveBlurEffect;
    StormBlink stormBlinkEffect;
    Edge       edgeEffect;
    Geometry   geometryEffect;

    const std::array<Effect*, 5> effects{&pixelateEffect, &waveBlurEffect, &stormBlinkEffect, &edgeEffect, &geometryEffect};

    std::size_t current = 0;

    // Initialize them
    for (Effect* effect : effects)
        effect->load();

    // Create the messages background
    sf::Texture textBackgroundTexture;
    if (!textBackgroundTexture.loadFromFile("resources/text-background.png"))
        return EXIT_FAILURE;
    sf::Sprite textBackground(textBackgroundTexture);
    textBackground.setPosition({0.f, 520.f});
    textBackground.setColor(sf::Color(255, 255, 255, 200));

    // Create the description text
    sf::Text description(font, "Current effect: " + effects[current]->getName(), 20);
    description.setPosition({10.f, 530.f});
    description.setFillColor(sf::Color(80, 80, 80));

    // Create the instructions text
    sf::Text instructions(font, "Press left and right arrows to change the current shader", 20);
    instructions.setPosition({280.f, 555.f});
    instructions.setFillColor(sf::Color(80, 80, 80));

    // Start the game loop
    const sf::Clock clock;
    while (window.isOpen())
    {
        // Process events
        for (sf::Event event; window.pollEvent(event);)
        {
            // Close window: exit
            if (event.type == sf::Event::Closed)
                window.close();

            if (event.type == sf::Event::KeyPressed)
            {
                switch (event.key.code)
                {
                    // Escape key: exit
                    case sf::Keyboard::Key::Escape:
                        window.close();
                        break;

                    // Left arrow key: previous shader
                    case sf::Keyboard::Key::Left:
                        if (current == 0)
                            current = effects.size() - 1;
                        else
                            --current;
                        description.setString("Current effect: " + effects[current]->getName());
                        break;

                    // Right arrow key: next shader
                    case sf::Keyboard::Key::Right:
                        if (current == effects.size() - 1)
                            current = 0;
                        else
                            ++current;
                        description.setString("Current effect: " + effects[current]->getName());
                        break;

                    default:
                        break;
                }
            }
        }

        // Update the current example
        const auto [x, y] = sf::Vector2f(sf::Mouse::getPosition(window)).cwiseDiv(sf::Vector2f(window.getSize()));
        effects[current]->update(clock.getElapsedTime().asSeconds(), x, y);

        // Clear the window
        if (effects[current]->getName() == "Edge Post-effect")
        {
            window.clear(sf::Color::White);
        }
        else
        {
            window.clear(sf::Color(50, 50, 50));
        }

        // Draw the current example
        window.draw(*effects[current]);

        // Draw the text
        window.draw(textBackground);
        window.draw(instructions);
        window.draw(description);

        // Finally, display the rendered frame on screen
        window.display();
    }
}