mirror of
https://github.com/SFML/SFML.git
synced 2024-11-28 22:31:09 +08:00
eb4170796a
This example is optional since it may be skipped on hardware where
geometry shaders are not supported. The way I rewrote it in 7234fc1
resulted in the shader still being attempted to be loaded even when
geometry shaders were not supported leading to the whole program
crashing.
My bad.
448 lines
15 KiB
C++
448 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);
|
|
|
|
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{sf::Shader::loadFromFile("resources/pixelate.frag", sf::Shader::Type::Fragment).value()};
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// "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});
|
|
|
|
return true;
|
|
}
|
|
|
|
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{sf::Shader::loadFromFile("resources/wave.vert", "resources/blur.frag").value()};
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// "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}});
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
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{sf::Shader::loadFromFile("resources/storm.vert", "resources/blink.frag").value()};
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// "Edge" post-effect fragment shader
|
|
////////////////////////////////////////////////////////////
|
|
class Edge : public Effect
|
|
{
|
|
public:
|
|
Edge() : Effect("Edge Post-effect")
|
|
{
|
|
}
|
|
|
|
bool onLoad() override
|
|
{
|
|
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);
|
|
}
|
|
|
|
// Set the shader uniform
|
|
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::RenderTexture::create({800, 600}).value()};
|
|
sf::Texture m_backgroundTexture;
|
|
sf::Texture m_entityTexture;
|
|
std::optional<sf::Sprite> m_backgroundSprite;
|
|
std::vector<sf::Sprite> m_entities;
|
|
sf::Shader m_shader{sf::Shader::loadFromFile("resources/edge.frag", sf::Shader::Type::Fragment).value()};
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// "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
|
|
m_shader = sf::Shader::loadFromFile("resources/billboard.vert",
|
|
"resources/billboard.geom",
|
|
"resources/billboard.frag");
|
|
if (!m_shader)
|
|
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;
|
|
std::optional<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
|
|
const auto font = sf::Font::loadFromFile("resources/tuffy.ttf").value();
|
|
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
|
|
while (const auto event = window.pollEvent())
|
|
{
|
|
// Close window: exit
|
|
if (event.is<sf::Event::Closed>())
|
|
window.close();
|
|
|
|
if (const auto* keyPressed = event.getIf<sf::Event::KeyPressed>())
|
|
{
|
|
switch (keyPressed->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();
|
|
}
|
|
}
|