mirror of
https://github.com/SFML/SFML.git
synced 2024-11-28 22:31:09 +08:00
4315c3d290
This change was made in 359fe90 due to recommendations from tooling.
On its face this change makes sense since it removes a copy that
isn't always necessary. In practice it caused ergonomic issues due
to now being forced to make a copy of the render states when needed.
The performance gains of eliding this copy are unsubstantiated. We
have not done any profiling to measure its impact. For lack of such
measurements I'd rather err on the side of improved user experience.
If future benchmarks prove this copy is rather expensive then we
can reconsider removing it with that evidence in mind.
457 lines
15 KiB
C++
457 lines
15 KiB
C++
////////////////////////////////////////////////////////////
|
|
// Headers
|
|
////////////////////////////////////////////////////////////
|
|
#include "Effect.hpp"
|
|
|
|
#include <SFML/Graphics.hpp>
|
|
|
|
#include <array>
|
|
#include <optional>
|
|
#include <random>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <cmath>
|
|
#include <cstdint>
|
|
#include <cstdlib>
|
|
|
|
namespace
|
|
{
|
|
std::random_device rd;
|
|
std::mt19937 rng(rd());
|
|
} // namespace
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// "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, sf::RenderStates states) const override
|
|
{
|
|
states.shader = &m_shader;
|
|
target.draw(*m_sprite, states);
|
|
}
|
|
|
|
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, sf::RenderStates states) const override
|
|
{
|
|
states.shader = &m_shader;
|
|
target.draw(m_text, states);
|
|
}
|
|
|
|
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({{x, y}, {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, sf::RenderStates states) const override
|
|
{
|
|
states.shader = &m_shader;
|
|
target.draw(m_points, states);
|
|
}
|
|
|
|
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, sf::RenderStates states) const override
|
|
{
|
|
states.shader = &m_shader;
|
|
target.draw(sf::Sprite(m_surface.getTexture()), states);
|
|
}
|
|
|
|
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, sf::RenderStates states) const override
|
|
{
|
|
// Prepare the render state
|
|
states.shader = &m_shader;
|
|
states.texture = &m_logoTexture;
|
|
states.transform = m_transform;
|
|
|
|
// Draw the point cloud
|
|
target.draw(m_pointCloud, states);
|
|
}
|
|
|
|
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();
|
|
}
|
|
}
|