What do you get with a Packt Subscription?

Free for first 7 days. $24.99 p/m after that. Cancel any time!

Unlimited ad-free access to the largest independent learning library in tech. Access this title and thousands more!

50+ new titles added per month, including many first-to-market concepts and exclusive early access to books as they are being written.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

Thousands of reference materials covering every tech concept you need to stay up to date.

Subscribe now

View plans & pricing

SFML Blueprints

Chapter 1. Preparing the Environment

Through this book, I will try to teach you some elements to build video games using the SFML library. Each chapter will cover a different topic, and will require knowledge from the previous one.

In this first chapter, we will cover basics points needed for the future such as:

Installing a compiler for C++11
Installing CMake
Installing SFML 2.2
Building a minimal SFML project

Before getting started, let's talk about each technology and why we will use them.

C++11

The C++ programming language is a very powerful tool and has really great performance, but it is also really complex, even after years of practice. It allows us to program at both a low and high level. It's useful to make some optimizations on our program such as having the ability to directly manipulate memory. Building software utilizing C++ libraries allows us to work at a higher level and when performance is crucial, at a low level. Moreover, the C/C++ compilers are very efficient at optimizing code. The result is that, right now, C++ is the most powerful language in terms of speed, and thanks to the zero cost abstraction, you are not paying for what you don't use, or for the abstraction you are provided.

I'll try to use this language in a modern way, using the object-oriented approach. Sometimes, I'll bypass this approach to use the C way for optimizations. So do not be shocked to see some "old school code". Moreover, all the main compilers now support the standard language released in 2011, so we can use it everywhere without any trouble. This version adds some really useful features in the language that will be used in this book, such as the following:

Keywords are one such important feature. The following are a few of them:
- auto: This automatically detects the type of the new variable. It is really useful for the instantiation of iterators. The auto keyword already existed in the past, but has been deprecated for a long time, and its meaning has now changed.
- nullptr: This is a new keyword introducing a strong type for the old NULL value. You can always use NULL, but it's preferable to use nullptr, which is any pointer type with 0 as the value.
- override and final: These two keywords already exist in some languages such as Java. These are simple indications not only for the compiler but also for the programmer, but don't specify what they indicate. Don't hesitate to use them. You can take a look to the documentation of them here http://en.cppreference.com/w/cpp/language/override and http://en.cppreference.com/w/cpp/language/final.
The range-based for loops is a new kind of loop in the language foreach. Moreover, you can use the new auto keyword to reduce your code drastically. The following syntax is very simple:
```
for(auto& var : table){...}.
```
In this example, table is a container (vector and list) and var is a reference to the stored variable. Using & allows us to modify the variable contained inside the table and avoids copies.
C++11 introduces the smart pointers. There are multiple pointers corresponding to their different possible utilizations. Take a look at the official documentation, this which is really interesting. The main idea is to manage the memory and delete the object created at runtime when no more reference on it exists, so that you do not have to delete it yourself or ensure that no double free corruptions are made. A smart pointer created on the stack has the advantages of being both fast and automatically deleted when the method / code block ends. But it is important to know that a strong use of this pointer, more especially shared_ptr, will reduce the execution speed of your program, so use them carefully.
The lambda expression or anonymous function is a new type introduced with a particular syntax. You can now create functions, for example, as a parameter of another function. This is really useful for callback. In the past, functor was used to achieve this kind of comportment. An example of functor and lambda is as follows:
```
class Func(){ void operator()(){/* code here */}};
auto f = [](){/* code here*/};
```
If you already know the use of the variadics function with the ellipse operator (...), this notion should trouble you, as the usage of it is different. The variadics template is just the amelioration of template with any number of parameters using the ellipse operator. A good example for this is the tuple class. A tuple contains any number of values of any type known at compile time. Without the variadics template, it was not really possible to build this class, but now it is really easy. By the way, the tuple class was introduced in C++11. There are several other features, such as threads, pair, and so on.

Installing SFML 2.2

There are two ways to get the SFML library. The easier way is to download the prebuilt version, which can be found at http://sfml-dev.org/download/sfml/2.2/, but ensure that the version you download is compatible with your compiler.

The second option is to compile the library yourself. This option is preferable to the previous one to avoid any trouble.

Building SFML yourself

Compiling SFML is not as difficult as we might think, and is within the reach of everyone. First of all, we will need to install some dependencies.

Installing dependencies

SFML depends on a few libraries. Before starting to compile it, make sure that you have all the dependencies installed along with their development files. Here is the list of dependencies:

pthread
opengl
xlib
xrandr
freetype
glew
jpeg
sndfile
openal

Linux

On Linux, we will need to install the development versions of each of these libraries. The exact names of the packages depend on each distribution, but here is the command line for Debian:

sudo apt-get install libglu1-mesa-dev freeglut3-dev mesa-common-dev libxrandr-dev libfreetype6-dev libglew-dev libjpeg-dev libsndfile1-dev libopenal-dev -y

Other operating systems

On Windows and Mac OS X, all the needed dependencies are provided directly with SFML, so you don't have to download or install anything. Compilation will work out of the box.

Compilation of SFML

As mentioned previously, the SFML compilation is really simple. We just need to use CMake, by following these steps:

Download the source code at http://sfml-dev.org/download/sfml/2.2/ and extract it.
Open CMake and specify the source code directory and the build directory. By convention, the build directory is called build and is at the root level of the source directory.
Press the Configure button, and select Code::Blocks with the right option for your system.
Under Linux, choose Unix Makefiles. It should look like this:
Under Windows, choose MinGW Makefiles. It should look like this:
And finally, press the Generate button. You'll have an output like this:

Now the Code::Blocks file is built, and can be found in your build directory. Open it with Code::Blocks and click on the Build button. All the binary files will be built and put in the build/lib directory. At this point, you have several files with an extension that depend on your system. They are as follows:

libsfml-system
libsfml-window
libsfml-graphics
libsfml-audio
libsfml-network

Each file corresponds to a different SFML module that will be needed to run our future games.

Now it's time to configure our system to be able to find them. All that we need to do is add the build/lib directory to our system path.

Linux

To compile in Linux, first open a terminal and run the following command:

cd /your/path/to/SFML-2.2/build

The following command will install the binary files under /usr/local/lib/ and the headers files in /usr/local/include/SFML/:

sudo make install

By default, /usr/local/ is in your system path, so no more manipulations are required.

Windows

On Windows, you will need to add to your system path, the /build/lib/ directory, as follows:

Go to the Advanced tab in System Properties, and click on the Environment Variables button:
Then, select Path in the System variables table and click on the Edit... button:
Now edit the Variable value input text, add ;C:\your\path\to\SFML-2.2\build\lib, and then validate it by clicking on OK in all the open windows:

At this point, your system is configured to find the SFML dll modules.

Code::Blocks and SFML

Now that your system is configured to find the SFML binary files, it's time for us to configure Code::Blocks and finally test whether everything is fine with your fresh installation. To do so, follow these steps:

Run Code::Blocks, go to File | New | Project, and then choose Console Application.
Click on GO.
Choose C++ as the programming language, and follow the instructions until the project is created. A default main.cpp file is now created with a typical Hello world program. Try to build and run it to check whether your compiler is correctly detected.

If everything works correctly, you will have a new window created that has a Hello world! message, as follows:

If you have this output, everything is fine. In any other case, make sure you have followed all the steps for the installations.

Now we will configure Code::Blocks to find the SFML library, and ask it to link with our program at the end of the compilation. To do this, perform the following steps:

Go to Project | Build options and select your project at the root level (not debug or release).
Go to Search directories. Here we have to add the path where the compiler and the linker can find the SFML.
For the compiler, add your SFML folder.
For the linker, add the build/lib folder, as follows:

Now we need to ask the linker which libraries our project needs. All our future SFML projects will need the System, Window, and Graphics modules, so we will add them:

Go to the Linker settings tab.
Add -lsfml-system, -lsfml-window and -lsfml-graphics in the Other linker options column.
Now click on OK.

Good news, all the configurations are now finished. We will eventually need to add a library to the linker in the future (audio, network), but that's it.

A minimal example

It's now time for us to test the SFML with a very basic example. This application will show us the window as in the following screenshot:

The following code snippet brings about this window:

int main(int argc,char* argv[])
{
    sf::RenderWindow window(sf::VideoMode(400, 
400),"01_Introduction");
    window.setFramerateLimit(60);

    //create a circle
    sf::CircleShape circle(150);
    circle.setFillColor(sf::Color::Blue);
    circle.setPosition(10, 20);

    //game loop
    while (window.isOpen())
    {
       //manage the events
        sf::Event event;
        while(window.pollEvent(event))
        {
            if ((event.type == sf::Event::Closed)
                or (event.type == sf::Event::KeyPressed and 
event.key.code == sf::Keyboard::Escape))
                window.close(); //close the window
        }
        window.clear(); //clear the windows to black
        window.draw(circle); //draw the circle
        window.display(); //display the result on screen
    }
    return 0;
}

All that this application does is to create a window with a width and height of 400 pixels and its title is 01_Introduction. Then a blue circle with a radius of 150 pixels is created, and is drawn while the window is open. Finally, the user events are checked on each loop. Here we verify if the close event has been asked (close the button or click Alt + F4), or if the user has pressed the Esc button on his keyboard. In both case, we close the window, that will result to the program exit.

What you will learn

Build a complete game and integrate advanced features by adding a multiplayer layer

Get to grips with SFML resources and build a generic and reusable resource manager

Gather knowledge about different entity models and build your own 2D games

Explore the Box2D engine and add physics properties to your game

Add a nice user interface to your game to make it more user friendly

Discover the SFGUI library and learn how to customize your game

Delve into the importance of multithreading and boost your code

Add networking and learn about serialization and database management using Sqlite3

What do you get with a Packt Subscription?

Free for first 7 days. $24.99 p/m after that. Cancel any time!

Unlimited ad-free access to the largest independent learning library in tech. Access this title and thousands more!

50+ new titles added per month, including many first-to-market concepts and exclusive early access to books as they are being written.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

Thousands of reference materials covering every tech concept you need to stay up to date.

Subscribe now

View plans & pricing

Frequently bought together

AU$67.99

AU$60.99

AU$75.99

Total AU$ 204.97

CS Oct 10, 2015

This book has good knowledge on basics of SMFL Library. You can learn to make small 2D games, with C++ and SMFL. Good book overall, and useful for understanding SMFL.

Amazon Verified review

Amazon Customer Nov 12, 2015

Someone fairly new to C++ will find making the code samples into a working project quite tough. Although I would say it was not too tough.For example the Asteroids, Tetris and real-time multi-player tower defence game were straight-forward enough to get playing.The strength of this book is really in it's sheer variety of projects(blueprints). If you want a really convincing SFML patterns guide maybe research SFML Game Development . If you want to build multiple working games packed full of the different SFML module's functionality then I have to say this book was seriously fun.Tetris with box2d is a hilarious but really useful project.

Zach Wilder Jan 11, 2016

The examples in this book are clear, well thought out, and (relatively) easy to follow. I would STRONGLY recommend a firm grasp on C++, as most of the examples could be hard to put together for a complete beginner.The example games were a blast to put together, and they do a pretty good job of illustrating the various features of the SFML library.Now, why this book should really be considered 3.5 stars and not a solid 4 - The authors should have hired an editor who can speak/write English competently. There are many typos and grammatical errors throughout the book, which detracts from the excellent job the authors did with the code. For example: "The is no member here, and the class can't be instantiate. [...] So here, only one collision test is describe that take two sf::Sprite as parameters. Take a look to the implementation." (pg 72) In addition, the code examples are spread out in a strange manner that makes it a bit difficult to read, and the typos do carry over to the code - so I would recommend you keep an eye on what you are actually typing.If you want to have fun while learning some cool tricks with SFML, I'd highly recommend this book. I wouldn't hesitate to buy another book from the same author, even with the issues above, and will probably pick up the other SFML books soon.

Barron Fritz Aug 01, 2015

At the end of chapter 2, so my review does not reflect the work in it's entirety.. I will leave a full review once I have completed it.Chapter 1 is all about Setting up your environment on whatever OS you choose(Windows, OSX or *nix) and it goes into presice detail on exactly how to set things up. At the end of chapter 1 you create "A minimal example" program to make sure that the library and your programming environment is set up properly. It shows a picture of the final result, shows the code in order to get this result, and then explains exactly what each part of code does. 5 Stars on Chapter 1.Chapter 2 starts out explaining what the different parts of a game are, and what they are intended to do. You extract your minimal example into it's own "Game" class and break apart each functional piece of code into it's own function. The next part goes into explaining different game loops time-steps or update cycles. I think the Author does a good job explaining Why you would need each kind of type-step and how to implement them, in a very general/basic way. Now we are in to user inputs and how the game will react to such things. At first, a 'minimal' example is given for handling Polled input and Real-Time input. Almost immediately, and with no clear reason or purpose You are instructed to create 2 new classes for handling real-time user input. The book fell apart for me here, and the code shown in the book does not match the code given in the code samples (eg. assignment operators are defined but never declared, namespace "book::" shows up out of nowhere (never mentioned) and causes errors, and the code does not compile at the end of the chapter.)I'm going to give This "hickup" the bennefit of the doubt, and wait till I finish the book to write a full review. Please take this review with a grain of salt, and Note this is for the first Edition, PDF/Kindle copy from PacktPub, and these flaws may be corrected in future editions.

SFML Blueprints: Sharpen your game development skills and improve your C++ and SFML knowledge with five exciting projects

What do you get with a Packt Subscription?

SFML Blueprints

Chapter 1. Preparing the Environment

C++11

SFML

Installation of a C++11 compiler

For Linux users

For Mac users

For Windows users

For all users

Installing CMake

For Linux users

For other operating systems

Installing SFML 2.2

Building SFML yourself

Installing dependencies

Linux

Other operating systems

Compilation of SFML

Linux

Windows

Code::Blocks and SFML

A minimal example

Summary

Page 1 of 7

Description

Who is this book for?

What you will learn

Product Details

What do you get with a Packt Subscription?

Product Details

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

People who bought this also bought

About the author

FAQs

SFML Blueprints: Sharpen your game development skills and improve your C++ and SFML knowledge with five exciting projects

What do you get with a Packt Subscription?

Installing dependencies

Linux

Other operating systems

Compilation of SFML

Linux

Windows

Description

Who is this book for?

What you will learn

Product Details

What do you get with a Packt Subscription?

Product Details

Packt Subscriptions

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

People who bought this also bought

About the author

FAQs