Thor C++ Library – An SFML extension

[Nexus]

[Edit] This post is outdated. Please use now this thread to discuss about the next version of Thor.

Good evening,

I would like to present a project I have been working on the last time. Thor is an open-source C++ library which provides extensions of SFML. There have been a lot of feature requests in the forum that were either too high level or out of scope for integration into SFML. Nevertheless, some of them are very useful in game and multimedia programming. That is why I have implemented some of them, hoping that SFML users can benefit from the functionality.

Thor is completely free to use, like SFML it is licensed under zlib/libpng.


Features

The Thor C++ library comes with the following small modules:

Vectors
- 2D Vector algebra functions: Dot product, compute length and angles, ...
- 3D Vector algebra functions: Dot and cross product, compute length and angles, ...
- PolarVector: 2D vector class that stores polar coordinates

Geometry
- Zone class hierarchy for geometric figures
- Base classes for positionable, rotatable and scalable objects

Particles
- ParticleSystem class based on sf::Image, stores and manages particles (lifetime, transformations, color, ...)
- Customizable Emitter and Affector classes

Events
- SfmlEventSystem class to handle SFML events via callbacks
- EventSystem template for user-defined events

Resources
- ResourceManager class template that allows safe and easy loading, storage and access to resources
- ResourcePtr provides shared access to resources
- Predefined helper classes for SFML resources like sf::Image

Multimedia
- ConcaveShape class: As an extension to sf::Shape, it works with concave shapes
- Arrow class to visualize vectors
- Color blending and simple construction of color gradients
- String conversion functions for a few SFML classes like sf::Vector

Time
- StopWatch class: Wrapper around sf::Clock for pausable clocks
- Timer class: Countdown mechanism
- TriggeringTimer class: Countdown invoking callbacks at expiration

Tools
- SingleDispatcher: Dynamic dispatch to unary functions
- DoubleDispatcher: Dynamic dispatch to binary functions (multimethods)
- Other utility like foreach macros

SmartPtr
- ScopedPtr: Local RAII smart pointer
- MovedPtr: Movable smart pointer implementation
- CopiedPtr: Smart pointer with deep copy semantics

Math
- Generalization of trigonometry functions
- Random number generator based on TR1
- Delaunay triangulation


Download

You can download version 1.0 directly on my homepage. You will also find tutorials and the API documentation there. I use CMake to build the source code, but I also supply precompiled binaries for some configurations. Note that the library bases on the newest Git revisions of SFML 2.

In the next days, I am going to setup an SVN repository so that you are able to follow the development of the Thor C++ library.


Outlook

I try to improve the library continuously, so I appreciate feedback, be it bug reports, feature requests or general discussions. Let me know what you like to be part of Thor, and I can think about it. One of the tasks I am planning to implement in near future is a design that allows easy animations with sf::Sprite, another example is a Z buffer.

[Laurent]

Very nice project

I'll try to have a deeper look at it when I have some free time.

It will also make my life much easier:

User X: "can you please implement xxx in SFML?"
Laurent: "no way... but ask Nexus"

:mrgreen:

[Groogy]

Just wondering if you want to extend it with some threading utilities? I'll soon be done with my "extension" or whatever you'd like to call it. It includes synchronization between threads, Thread pool and Job management.

Currently only got Job management left.

[WitchD0ctor]

Not gonna lie, that triangulation demo was really sexy.
would be really useful for creating box2d shapes!

[phoekz]

Definitely going to use this in my project, going to love particles and more functional clock/timer. It looks fairly simple even for a beginner. Going to toy around with this tonight .

[Hubert]

Thanks you so much.  
A lot a usefull things that I'm going to use in my projet.

[Nexus]

I'm glad that you find it useful

Just wondering if you want to extend it with some threading utilities?

Probably not, at least not in near future. I'd rather like to concentrate on improving and extending the current modules for now. Also, my own experience with multithreading is pretty limited

[xazax]

I always missed some extended vector functionality . I hope there is a chance to backport some of those features to core SFML.

[Nexus]

I always missed some extended vector functionality

A lot of people did (including myself), so Thor seemed to be a good opportunity

By the way, the SVN repository is now online, the URL of the trunk is http://www.bromeon.ch/svn/thor/trunk.

[xazax]

Nice one, thank you very much.

[Nexus]

In the meantime, I have implemented parts of a new event action system. This allows the dynamic mapping from arbitrary identifiers to specific keys, and combinations of them using OR and AND operators.

You can get the code via SVN. Here is an example:

Code: [Select]

#include <Thor/Events.hpp>
#include <SFML/Window.hpp>
#include <iostream>
#include <string>

int main()
{
// Create window, set initial settings
sf::Window window(sf::VideoMode(400, 300), "Thor Action Demo");
window.SetFramerateLimit(20);
window.EnableKeyRepeat(false);

// Create action map: std::string -> thor::Action
using thor::Action;
thor::ActionMap<std::string> map(window.GetInput());

// Run: Press one of the Shift keys and R (realtime input)
map["run"] = (Action(sf::Key::LShift) || Action(sf::Key::RShift)) && Action(sf::Key::R);

// Shoot: Press S or release D (single events)
map["shoot"] = Action(sf::Key::S, Action::PressOnce) || Action(sf::Key::D, Action::ReleaseOnce);

// Leave: Press escape
map["quit"] = Action(sf::Key::Escape, Action::PressOnce);

while (window.IsOpened())
{
// Clear temporarily pushed events
map.ClearEvents();

// Handle events
sf::Event event;
while (window.PollEvent(event))
map.PushEvent(event);

// Check which actions are active
if (map.IsActive("run"))
std::cout << ".";
if (map.IsActive("shoot"))
std::cout << "*";
if (map.IsActive("quit"))
return 0;

window.Display();
}
}
I am going to add support for mouse and joystick. What do you think about it?

[Laurent]

Looks really good so far, I like the API.

But you shouldn't use const char* keys. Comparisons should fail, since it compares the pointer values and not the actual strings. std::string would be better. If it works, I guess it's only because your compiler uses the same memory area for two occurences of the same string literal.

[Nexus]

I first had std::string, and somehow I thought char pointers would be enough (don't ask why . But you are of course right, thanks for the hint. I have fixed it.

By the way, mouse and joystick are now supported. I'd like to hear some feed-back concerning the API and functionality!

[WitchD0ctor]

wow, those Action Events are looking real tasty.

[Astrof]

whoa NICE! I haven't looked into SFML for like...two years or so? But wanted to get back into a mini project or two.  Love the inclusion of the particle engine.  

So I haven't looked into it too much yet (don't shoot me) but was wondering, so the triangulation ties in with box2D? My previous project died because something was wrong with wither box2D or the Spark particle engine that I was using.