SFML

Drop shadows in SFML

Drop shadows are created using a Gaussian blur drawn underneath the original element. You can do this using either a fixed texture or a post-processing fragment shader.

A Comparison of GUI Libraries for SFML: TGUI vs SFGUI vs IMGui and more

SFML is an excellent library that can be used to create 2D games in C++. It’s an abstraction over OpenGL and various system APIs, presenting a consistent and nice interface.

Rendering a topdown world with multiple layers and z-levels using SFML

Ruben’s Virtual World Project is a game I’ve been working on for almost 4 years now. Recently I rewrote the rendering code to support voxel lighting and multiple z-level - heights of the map.

Multiplayer Topdown Sandbox Game in C++

For the last two years, I have been working on a very ambitious game. The game is a top-down sandbox with multiplayer support. I’m aiming towards a city-based game, where players can wander around a procedurally generated city. One of the main reasons I started creating this game is to learn about multiplayer networking at a low level - client-side prediction, server-side reconcilliation, cheat preventation, and reducing the visual effect of latency.

How to emit a single particle using SFML's Thor Particle System

Usecase: shells dropping in sync with firing, fake bullets, etc

You must use a particle emitter to create particles, however this doesn’t mean it’s impossible to create single particles on command. You can create a particle emitter which simply adds particles from a queue to the system

#pragma once
#include <SFML/Graphics.hpp>
#include <Thor/Math.hpp>
#include <Thor/Graphics.hpp>
#include <Thor/Particles.hpp>

namespace sfext {

class SingleParticleEmitter
{
    std::vector<thor::Particle> *particles;
public:
    SingleParticleEmitter();
    SingleParticleEmitter(const SingleParticleEmitter& that);
    void operator() (thor::EmissionInterface& system, sf::Time dt);

    void push(thor::Particle particle);
    void push(sf::Vector2f position, sf::Vector2f velocity, float lifetime, float rot=0, float rotsp=0);
};

}; // end namesapce sfext

The above allows you to use the push functions to emit particles. Here is an example of it in use:

SingleParticleEmitter single_emitter;
thor::ParticleSystem particle_system;
particle_system.addEmitter(single_emitter);

// When you need to emit a shell:

single_emitter.push(origin, velocity, 1.0f);
// lifetime of the particle in seconds --^

Here is the cpp file:

#include "singleparticleemitter.hpp"

using namespace sfext;

SingleParticleEmitter::SingleParticleEmitter()
{
    particles = new std::vector<thor::Particle>();
}

SingleParticleEmitter::SingleParticleEmitter(const SingleParticleEmitter& that)
{
    particles = that.particles;
}

void SingleParticleEmitter::operator() (thor::EmissionInterface& system, sf::Time dt)
{
    for (auto particle : *particles) {
        system.emitParticle(particle);
    }
    particles->clear();
}

void SingleParticleEmitter::push(thor::Particle particle)
{
    particles->push_back(particle);
}

void SingleParticleEmitter::push(sf::Vector2f position, sf::Vector2f velocity, float lifetime, float rot, float rotsp)
{
    thor::Particle particle(sf::seconds(lifetime));
    particle.position = position;
    particle.velocity = velocity;
    particle.rotation = rot;
    particle.rotationSpeed = rotsp;
    particle.scale = sf::Vector2f(1.f, 1.f);
    particle.color = sf::Color::White;
    particle.textureIndex = 0u;
    push(particle);
}
How to center a SFGUI window (sfg::Window)

Simply get the SFGUI window size using GetAllocation, the sfml window size using getSize, then do this arithmetic:

auto window = sfg::Window::Create();
auto win_rect = window->GetAllocation();
sf::Vector2f size(win_rect.width, win_rect.height);
window->SetPosition(((sf::Vector2f)rwindow->getSize() - size) / 2.0f);