SFML community forums

General => SFML development => Topic started by: eXpl0it3r on August 22, 2018, 04:52:22 pm

Title: SFML Roadmap
Post by: eXpl0it3r on August 22, 2018, 04:52:22 pm
I'd like to discuss the next few steps for SFML's development. I've worded it as if things are already decided, but in fact it's all up for discussion.

Let's start with the big elephant in the room: SFML 3


The bad news: It's impossible to integrate all the changes we have promised, discussed or wished for (https://en.sfml-dev.org/forums/index.php?topic=15027.0) over the past years.
The amount of potential API changes and redesigns is too great to fit into one version of SFML.

The good news: It has become clearer over the past few years, that a lot of people have adapted the "new" C++ standards and are looking for APIs that do support modern C++ (e.g. move-semantics), but also don't feel particual motivated to contribute to "old" C++ code bases like SFML.


SFML 3 will first and foremost focus on introducing the C++17 standard (https://en.sfml-dev.org/forums/index.php?topic=21571.30) to the SFML code base and to get rid of some baggage.
Additional API changes or redesigns have second priority on the list.

The overall goal is to accept that major version updates don't require massive library evolutions on the scale of barely achievable, but that breaking changes should be able to happen more frequently and within a manageable scope.
This also implies that we'll actively try to avoid dragging a major version on for many years, which has the the effect, that SFML 3 will end up rather short-lived compared to SFML 2.

Here's a rough roadmap what the goal is in the near future:

SFML 2.6 (see GitHub Project (https://github.com/SFML/SFML/projects/4) for details)

SFML 3

Priority 1

Priority 2

Backports

We're generally open to backporting critical bug fixes to SFML 2, but it will be decided on a case-by-case basis and the focus should really be in moving forward.

Summary

The current roadmap moves SFML 3 from an infinitely far away horizon to the next version after SFML 2.6. Major versions don't require massive API evolutions, but it simply indicates a breaking change.

I'm interested in hearing what people think of this proposal, so let the discussion begin!
Keep in mind though, that the point of the discussion here, isn't necessarily about a single item on the list, but it should be more on the whole perspective change.
Title: Re: SFML Roadmap
Post by: Rosme on August 22, 2018, 05:12:39 pm
Good idea this thread, thanks eXpl0it3r.

My first question is why C++14 for SFML 3.0? C++17 is already standard and is relatively well supported at this moment by every major compiler (according to this page (https://en.cppreference.com/w/cpp/compiler_support)). By the time SFML 3.0 will come out, it will definitely be supported.

Considering how many people seems to ask for filesystem support(and possibily other features), supporting C++17 directly solves that kind of problem, instead of having SFML implementing, only to deprecate it not long after (std::thread vs sf::thread comes to my mind about this). I would expect sf::Thread to be altogether removed anyway from SFML 3.0.

As for the setup for backends, I think it could be very interesting to discuss the possibility of doing such thing. Could also help to port it to more esoteric platform (Xone, PS4, Switch, etc.). I'm all for that, although I understand the work to do something like this can be quite huge.

Finally, while it's nice to add all the things mentions in the list to SFML 2.6, why not start focusing on SFML 3.0 directly for some of those? Scan codes are well advanced that it makes sense, but the rest could probably be more part of SFML 3.0 development directly, making the release of that version earlier than expected, which can only be appreciated.
Title: Re: SFML Roadmap
Post by: eXpl0it3r on August 22, 2018, 05:26:56 pm
My first question is why C++14 for SFML 3.0? C++17 is already standard and is relatively well supported at this moment by every major compiler (according to this page (https://en.cppreference.com/w/cpp/compiler_support)). By the time SFML 3.0 will come out, it will definitely be supported.
Support and adoption are two separate things, but I generally agree that C++17 would provide some additional possibilities. I'd like to see the original C++ Standard discussion (https://en.sfml-dev.org/forums/index.php?topic=21571.0) to be picked up and continued in its dedicated thread.

As for the setup for backends, I think it could be very interesting to discuss the possibility of doing such thing. Could also help to port it to more esoteric platform (Xone, PS4, Switch, etc.). I'm all for that, although I understand the work to do something like this can be quite huge.
It's certainly a discussion to be had and also check on a technical level what could be done.

Finally, while it's nice to add all the things mentions in the list to SFML 2.6, why not start focusing on SFML 3.0 directly for some of those? Scan codes are well advanced that it makes sense, but the rest could probably be more part of SFML 3.0 development directly, making the release of that version earlier than expected, which can only be appreciated.
There are already many things near completion for SFML 2.6 - if you check the GitHub Project you see that a lot of things are already in review/testing state or at least WIP.
Plus as I said the focus of SFML 3 should be to introduce C++14, clean up some baggage, but it shouldn't be focused on building many new features.
Title: Re: SFML Roadmap
Post by: Klaim on August 28, 2018, 12:11:30 pm
Would it be ok to consider switching to using a dependency management tool for that version?
I'm thinking mainly about solving the issue of having binary dependencies inside the extlibs directory.
Title: Re: SFML Roadmap
Post by: eXpl0it3r on August 28, 2018, 12:34:24 pm
In some endless discussion quite a while back it was decided to move the dependencies into its own repository, but in the end we never did it.

At this point no dependency manager has been well established in the C++ community, as such I don't think we should require one or the other flavor. However I think if we could do it transparently with CMake while you're building, it might be something to think about.
Title: Re: SFML Roadmap
Post by: Klaim on August 28, 2018, 02:26:58 pm
Indeed at least separating them would help.

Using CMake apparently would work with recent versions but I didnt try (last time I used ExternalDependency module it failed quite spectacularly for my use case but it was a very complex use case). I know they made efforts in this direction but it's only available in last version(s).

I think at least separating the dependencies and listing the package names and versions somewhere in the root directory would be a good first step for the future of this project's dependenies management.
I guess I long as it's easy for beginner (one command to get everything), it should be fine.
Title: Re: SFML Roadmap
Post by: eXpl0it3r on May 26, 2020, 11:50:33 pm
I updated the initial post with more recent information and further reduced the scope of SFML 2.6 (https://github.com/SFML/SFML/projects/4).

Additionally, I have been slowly making progress on the Scancode topic (https://github.com/SFML/SFML/wiki/SD:-Scancodes) so we can close the last, big remaining feature for SFML 2.6.
Title: Re: SFML Roadmap
Post by: Nexus on June 18, 2020, 11:06:41 pm
[Edit] Now that I think about it, this might as well be its own topic. Feel free to split, if you want to keep this thread focused on the high-level roadmap, without going into detail about C++ related API changes.



Maybe we should start discussing the bigger API changes, especially those that break existing code.
I'm just brainstorming here, so all I write is neither complete nor definitive.

Here's a good overview over new library and language features for all C++ standards. (https://github.com/AnthonyCalandra/modern-cpp-features)

Error Handling
It would be nice if resources could be returned from factories (named constructors), such as:
sf::Texture tex = sf::Texture::loadFromFile(...);
sf::Image img = sf::Image::loadFromMemory(...);

It would need to be discussed what to do in the error case.

Major removed APIs
Main candidate I see is sf::Thread.
With it come sf::ThreadLocal and sf::ThreadLocalPtr.

It can be discussed whether sf::Time is necessary given std::chrono, but the latter is very generic and can be overwhelming for the small amount of functionality that SFML needs. Interop (conversion from/to) should definitely be provided though.


Filesystem and path
C++17 Filesystem could benefit both public API and implementation.
If it's too tedious to construct strings to be used in place of std::filesystem::path, convenience overloads for sf::String or const char* can be offered.



Ownership and smart pointers
I can't think of a vast number of places where SFML would benefit from smart pointers, but I could imagine that std::unique_ptr and std::shared_ptr could clarify ownership semantics, when the library does not simply "borrow" (reference to) a user-created object, but (partially) own it.

std::unique_ptr in particular is a good abstraction boundary, when pointers to abstract base classes, such as sf::Drawable or sf::Shape have to be moved (ownership-transferred).

Apart from that, move semantics should be employed in the library, mainly for heavy resources.


New emerged idioms
Smaller things like:Out of scope
I think we also have to be careful what not to include. In particular, we should not have the mindset "this feature is new, so we have to use it", but rather evaluate on a case-to-case basis, if a new C++ language/library feature actually fits in the scope.

Some things I'm thinking of that should be used with care:
Title: Re: SFML Roadmap
Post by: unlight on June 20, 2020, 02:14:54 am
This is a really good conversation starter Nexus! I have some thoughts in response..

Error Handling
I don't like the idea of having resources constructed through factory methods. Once we get move semantics implemented, you could implement your own factory methods that handle errors in what ever way you like. Forcing an error handling method would be an opinionated debate with no right or wrong answers.

Major removed APIs
I agree that sf::Thread has no place anymore, but totally support keeping sf::Time for the reduced verbosity. We could add an std::chrono::duration operator to the Time class so that it works natively with std::thread::sleep functions.


Ownership and smart pointers
I like the idea of using std::unique_ptr for handling object lifetimes inside SFML classes, but personally would prefer if SFML never forced the user to create a smart pointer to interact with the library. This is just personal preference, it would be good to hear what others thought.
Title: Re: SFML Roadmap
Post by: Nexus on June 21, 2020, 01:04:51 pm
Error Handling
I don't like the idea of having resources constructed through factory methods. Once we get move semantics implemented, you could implement your own factory methods that handle errors in what ever way you like. Forcing an error handling method would be an opinionated debate with no right or wrong answers.
The library still has to provide this functionality. "Opinionated" in this sense mostly means "consistent" and "that's the recommended way of doing it".

Currently, this API is
sf::Texture texture;
if (!texture.loadFromFile(...))
{
    // error handling
}
and this is equally opinionated, but has several technical drawbacks: easy to forget checking the return type, no const variables, no way to get error message/code, unclear semantics when re-loading (and failing), dealing with invalid (unloaded) states, etc.

Of course it can be discussed if this would remain the best API for SFML 3, but keep in mind that the original reason to do it like this was because SFML doesn't use exceptions, so constructors cannot fail.

Constructors on the other hand are not a good idea, as they cannot specify the source (file, memory, stream...), and this would need to be dispatched solely based on parameter types. There would already be conflicts now, e.g. with sf::Shader (https://www.sfml-dev.org/documentation/2.5.1/classsf_1_1Shader.php).

Hence the suggested named constructor idiom (factory) -- it's an established idiom and shines especially in combination with move semantics.
Title: Re: SFML Roadmap
Post by: eXpl0it3r on November 30, 2021, 02:59:37 pm
Some update on the current situation.

The scancode feature (https://github.com/SFML/SFML/pull/1235) is very slowly being finalized, it's still planned for SFML 2.6.

As there's a high interest (https://en.sfml-dev.org/forums/index.php?topic=28301.0) in getting the ball rolling for bringing C++17 to SFML and thus also starting off the development for SFML 3.

To achieve both of these goals, we created already a sort of release branch 2.6.x (https://github.com/SFML/SFML/tree/2.6.x) and will start development of SFML 3 on the master branch right now.
Title: Re: SFML Roadmap
Post by: eXpl0it3r on December 03, 2021, 04:37:33 pm
Not sure where to place the best, so I'll just do it here for now.

We want to document breaking changes on the following wiki page: https://github.com/SFML/SFML/wiki/SD:-SFML-3:-Breaking-Changes

This doesn't have to be elaborate in anyway, but I believe it's simpler to collect this information as we go, than try and reconstruct it after the fact.
The goal for me would be to write a sort of upgrade guide before the SFML 3 release.
Title: Re: SFML Roadmap
Post by: GallusGames on March 30, 2022, 02:24:49 pm
Looks good, but you should definitely plan smaller releases.

It is standard in game development to only use releases and not the master version. So we've been stuck on 2.5.1 for 4 years.
Title: Re: SFML Roadmap
Post by: Nexus on March 31, 2022, 05:36:42 pm
Looks good, but you should definitely plan smaller releases.
Generally I agree, during "stable" times this is the way to go and we have neglected this to some extent.

During a huge breaking change however (SFML 3), many small releases directly conflict with Semver, which is also good industry practice. I know that many libraries don't care about this, and it makes everyone's life harder and is one big reason why dependency management is such a mess in C++ (another reason being lack of standard tooling).

If we had released during the SFML 2->3 period, we would have had two options:
At the end of the day, both groups are faced with several iterations of breaking changes, just to maintain feature parity. Sometimes we might even revert previous changes. I'm not sure this is what we want.

When game developers prefer outdated releases over Git versions due to policies, that's a reasonable strategy when it comes to minimize the number of code adaptations (at the cost of one bigger change taking more time). But it's ultimately their decision, they are free to use an in-development version to benefit from cutting edge changes (at the risk of bugs and API changes). So everyone can choose a trade-off acceptable to them.

TLDR: it's a matter of communication -- I think the current model makes it relatively clear that the Git version is "in flux" while releases are stable.